#Import libraries : import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns from sklearn.model_selection import train_test_split

StudentRecord= pd.read_csv('/work/student_record_10k.csv') StudentRecord

StudentRecord.info()

#Checking for unique values in each column: for col in StudentRecord : print(col ," : " ,StudentRecord[col].unique())

StudentRecord['campus'].value_counts() StudentRecord['internship'].value_counts() #Removing rows with value less than 0 in both the columns : StudentRecord=StudentRecord[(StudentRecord['campus']>0)] StudentRecord=StudentRecord[(StudentRecord['internship']>0)]

course= ['c01', 'c02', 'c03', 'c04', 'c05', 'c06', 'c07', 'c08', 'c09', 'c10','academic'] StudentRecord[course]= StudentRecord[course].round()

print(StudentRecord['graduate_program'].nunique()) import warnings sns.distplot(StudentRecord['graduate_program'], bins=30) warnings.filterwarnings("ignore")

import pandas as pd # Define bin edges bin_edges = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0] StudentRecord['graduate_program'] = pd.cut(StudentRecord['graduate_program'], bins=bin_edges, labels=False) StudentRecord

# Split the Electives column into separate columns for each course electives = StudentRecord['elective'].str.split(expand=True) electives.columns = ['elective_{}'.format(i+1) for i in range(electives.shape[1])] for column in electives.columns[electives.columns.str.startswith('elective_')]: electives[column] = electives[column].str.replace('[', '').str.replace(']', '').str.replace('\'', '').str.replace('`', '').astype('category') electives

StudentRecord.dtypes

StudentRecord.describe()

from sklearn.tree import DecisionTreeClassifier from sklearn.metrics import classification_report, confusion_matrix from sklearn import tree from sklearn.tree import plot_tree #Declare X and y X = StudentRecord[['c01', 'c02', 'c03', 'c04', 'c05', 'c06', 'c07', 'c08', 'c09', 'c10', 'academic', 'campus', 'internship']] y = StudentRecord[['AtRisk']] #Split the training and testing dataset X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33,random_state = 42) # Train the model with hyperparameters classifier = DecisionTreeClassifier(max_depth=5, criterion='gini', splitter='best', min_samples_split=3, min_samples_leaf=1, max_features=None, random_state=42) classifier.fit(X_train, y_train) #Train the model #classifier = DecisionTreeClassifier() #classifier.fit(X_train, y_train) #Evaluate the model y_pred = classifier.predict(X_test) #Confusion matrix print(classification_report(y_test, y_pred)) # Plot the confusion matrix sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt="d", cmap="PiYG", cbar=False) plt.xlabel('Predicted') plt.ylabel('Actual') plt.show() #Visualize the result # Plot the Decision Tree plt.figure(figsize=(15,10)) # Set figure size plot_tree(classifier, filled=True, rounded=True, feature_names=X.columns, class_names=['0', '1', '2', '3'],max_depth=5) plt.show()

from sklearn.linear_model import LogisticRegression from sklearn.metrics import classification_report, confusion_matrix # Declare X and y X = StudentRecord[['c01', 'c02', 'c03', 'c04', 'c05', 'c06', 'c07', 'c08', 'c09', 'c10', 'academic', 'campus', 'internship']] y = StudentRecord['graduate_program'] # Define the bins and labels for each category bins = [-float('inf'), 0.5, float('inf')] labels = [0, 1] # Use pandas cut function to bin the target variable y = pd.cut(StudentRecord['graduate_program'], bins=bins, labels=labels) # Split the training and testing dataset X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42) # Train the model classifier = LogisticRegression(random_state=42) classifier.fit(X_train, y_train) # Evaluate the model y_pred = classifier.predict(X_test) # Confusion matrix confusion_mat = confusion_matrix(y_test, y_pred) print(confusion_mat) print(classification_report(y_test, y_pred)) # Plot the confusion matrix sns.heatmap(confusion_mat, annot=True, fmt="d", cmap="RdBu", cbar=False) plt.xlabel('Predicted') plt.ylabel('Actual') plt.show()

StudentRecord1=StudentRecord[['c01', 'c02', 'c03', 'c04', 'c05', 'c06', 'c07', 'c08', 'c09', 'c10', 'academic', 'campus', 'internship']] StudentRecord1.info()

from sklearn.model_selection import train_test_split from sklearn import svm from sklearn.metrics import classification_report, confusion_matrix #Creating a column 'placement_binary' StudentRecord['placement_binary'] = np.where(StudentRecord['placement'] >= 0.5, True, False) #Declare X and Y : X = StudentRecord[['c01', 'c02', 'c03', 'c04', 'c05', 'c06', 'c07', 'c08', 'c09', 'c10', 'academic', 'campus', 'internship']] y = StudentRecord['placement_binary'] #Spliting Testing and training data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20,random_state=42) #Train the model model = svm.SVC(kernel='linear') clf = model.fit(X_train, y_train) #Evaluate the model y_pred = clf.predict(X_test) #Confusion matrix print(confusion_matrix(y_test, y_pred)) print(classification_report(y_test, y_pred)) # Confusion matrix confusion_mat = confusion_matrix(y_test, y_pred) print(confusion_mat) print(classification_report(y_test, y_pred)) # Plot the confusion matrix sns.heatmap(confusion_mat, annot=True, fmt="d", cmap="RdBu", cbar=False) plt.xlabel('Predicted') plt.ylabel('Actual') plt.show()

from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error # Prepare the data X = StudentRecord[['campus']] y = StudentRecord['annual'] # Train a simple linear regression model regressor = LinearRegression() regressor.fit(X, y) # Predict the annual income y_pred = regressor.predict(X) # Plot the data and the linear regression line sns.scatterplot(x=X['campus'], y=y, color='blue') sns.lineplot(x=X['campus'], y=y_pred, color='red') plt.xlabel('Campus') plt.ylabel('Annual Income') plt.title(f'Simple Linear Regression: Campus vs. Annual Income') plt.show() # Calculate and print the mean squared error mse = mean_squared_error(y, y_pred) print(f"Mean Squared Error: {mse}")

import matplotlib.pyplot as plt import seaborn as sns import pandas as pd from sklearn.linear_model import Ridge from sklearn.linear_model import Lasso from sklearn.model_selection import train_test_split from sklearn.metrics import mean_squared_error # Declare X and y X = StudentRecord[['academic']] y = StudentRecord['annual'] # Split into training and testing data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Train the model- Ridge regularization alpha = 0.01 # Regularization strength for Ridge (you can adjust this value) ridge = Ridge(alpha=alpha) ridge.fit(X_train, y_train) # Train the model - Lasso regularization #alpha_lasso = 0.01 # Regularization strength for Lasso (you can adjust this value) #regressor_lasso = Lasso(alpha=alpha_lasso) #regressor_lasso.fit(X_train, y_train) # Predict the annual income y_pred_ridge = ridge.predict(X_test) #y_pred_lasso = regressor_lasso.predict(X_test) # Plot the data and the polynomial regression lines sns.scatterplot(x=X['academic'], y=y, color='blue') sns.lineplot(x=X_test['academic'], y=y_pred_ridge, color='red', label='Ridge') #sns.lineplot(x=X_test['academic], y=y_pred_lasso, color='green', label='Lasso') plt.xlabel('acdemic') plt.ylabel('Annual Income') plt.title(f'Simple Polynomial Regression with Regularization: Acedemic vs. Annual Income') plt.legend() plt.show() # Evaluating the results mse_ridge = mean_squared_error(y_test, y_pred_ridge) #mse_lasso = mean_squared_error(y_test, y_pred_lasso) print(f"Mean Squared Error (Ridge): {mse_ridge}") #print(f"Mean Squared Error (Lasso): {mse_lasso}")

import matplotlib.pyplot as plt import seaborn as sns import pandas as pd from sklearn.linear_model import LinearRegression from sklearn.model_selection import train_test_split from sklearn.metrics import mean_squared_error # Declare X and y X = StudentRecord[['academic', 'campus', 'internship']] # Select 'academic', 'campus', and 'internship' as predictor variables y = StudentRecord['annual'] # Select 'annual_income' as the target variable # Split into training and testing data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Train the model regressor = LinearRegression() regressor.fit(X_train, y_train) #Evaluate the model y_pred = regressor.predict(X_test) # Plot the predicted annual income and the actual annual income sns.scatterplot(x=y_test, y=y_pred) plt.xlabel('Actual Annual Income') plt.ylabel('Predicted Annual Income') plt.title('Multiple Linear Regression: Actual vs. Predicted Annual Income') plt.show() # Calculate and print the mean squared error mse = mean_squared_error(y_test, y_pred) print(f"Mean Squared Error: {mse}")

from sklearn.cluster import KMeans import matplotlib.pyplot as plt %matplotlib inline from sklearn.preprocessing import StandardScaler import numpy as np #Declare X X = StudentRecord[['c01', 'c02', 'c03', 'c04','c05','c06','c07','c08','c09','c10']] #clustering for columns 'c01' and 'c02' sse = [] # Identify the optimal number of k for clusters for k in range(2, 5): kmeans = KMeans(n_clusters=k, random_state=42) kmeans.fit(X) sse.append(kmeans.inertia_) # plot clusters for each value of k labels = kmeans.labels_ fig, ax = plt.subplots() scatter = ax.scatter(X.iloc[:, 0], X.iloc[:, 1], c=labels) ax.set_xlabel('c01') ax.set_ylabel('c02') plt.colorbar(scatter) plt.title('K-Means Clustering with k='+str(k)) plt.show() # plot the within sum of squared distances vs k plt.plot(range(2, 5), sse, marker='o') plt.xlabel('Number of clusters') plt.ylabel('Sum of squared distances') plt.title('Elbow Method') # Identifying the optimal number of clusters using elbow method optimal_k = np.argmin(np.diff(sse)) + 2 plt.axvline(x=optimal_k, color='r', linestyle='--') plt.show() from sklearn.metrics import silhouette_samples, silhouette_score range_n_clusters = range(2, 5) silhouette_scores = [] for n_clusters in range_n_clusters: clusterer = KMeans(n_clusters=n_clusters, random_state=42) cluster_labels = clusterer.fit_predict(X) silhouette_avg = silhouette_score(X, cluster_labels) silhouette_scores.append(silhouette_avg) # plot the silhouette scores plt.plot(range_n_clusters, silhouette_scores, 'bx-') plt.xlabel('Number of clusters') plt.ylabel('Silhouette score') plt.title('Silhouette Method') # Identifying the optimal number of k using silhouette scores optimal_k = range_n_clusters[silhouette_scores.index(max(silhouette_scores))] plt.axvline(x=optimal_k, color='r', linestyle='--') plt.show() #clustering for columns 'c03' and 'c04' sse = [] # Identify the optimal number of k for clusters for k in range(2, 5): kmeans = KMeans(n_clusters=k, random_state=42) kmeans.fit(X) sse.append(kmeans.inertia_) # plot clusters for each value of k labels = kmeans.labels_ fig, ax = plt.subplots() scatter = ax.scatter(X.iloc[:, 2], X.iloc[:, 3], c=labels) ax.set_xlabel('c03') ax.set_ylabel('c04') plt.colorbar(scatter) plt.title('K-Means Clustering with k='+str(k)) plt.show() # plot the within sum of squared distances vs k plt.plot(range(2, 5), sse, marker='o') plt.xlabel('Number of clusters') plt.ylabel('Sum of squared distances') plt.title('Elbow Method') # Identifying the optimal number of clusters using elbow method optimal_k = np.argmin(np.diff(sse)) + 2 plt.axvline(x=optimal_k, color='r', linestyle='--') plt.show() from sklearn.metrics import silhouette_samples, silhouette_score range_n_clusters = range(2, 5) silhouette_scores = [] for n_clusters in range_n_clusters: clusterer = KMeans(n_clusters=n_clusters, random_state=42) cluster_labels = clusterer.fit_predict(X) silhouette_avg = silhouette_score(X, cluster_labels) silhouette_scores.append(silhouette_avg) # plot the silhouette scores plt.plot(range_n_clusters, silhouette_scores, 'bx-') plt.xlabel('Number of clusters') plt.ylabel('Silhouette score') plt.title('Silhouette Method') # Identifying the optimal number of k using silhouette scores optimal_k = range_n_clusters[silhouette_scores.index(max(silhouette_scores))] plt.axvline(x=optimal_k, color='r', linestyle='--') plt.show()

from sklearn.cluster import DBSCAN from sklearn.metrics import silhouette_score #Declare X X = StudentRecord[['c01', 'c02', 'c03', 'c04', 'c05', 'c06', 'c07', 'c08', 'c09', 'c10']] #Tuning epsilon and min_samples score = [] ep_value = [] min_samples = [] results = [] for ep in range(2,6): for min_sample in range(3,10): dbscan = DBSCAN(eps=ep, min_samples=min_sample) clusters = dbscan.fit(X) cluster_labels = dbscan.labels_ if len(set(cluster_labels)) == 1: continue silhouette_avg = silhouette_score(X, cluster_labels) results.append([ep, min_sample, silhouette_avg]) ep_value.append(ep) min_samples.append(min_sample) #Evaluation results DBresults = pd.DataFrame(results, columns=['Epsilon', 'MinPoints', 'SilhouetteScore']) DBresults.head()

# Cluster the data with optimal epsilon and min_samples values dbscan = DBSCAN(eps=2, min_samples=3) clusters = dbscan.fit_predict(X)

from sklearn.decomposition import PCA #Declare X X = StudentRecord[['c01', 'c02', 'c03', 'c04', 'c05', 'c06', 'c07', 'c08', 'c09', 'c10','academic', 'campus', 'internship']] #Train the model pca = PCA(n_components=3) X_pca = pca.fit_transform(X) print('% of explained variance with the 3 extracted features:', sum(pca.explained_variance_ratio_)*100, '%')

#Declare X X = StudentRecord[['c01', 'c02', 'c03', 'c04', 'c05', 'c06', 'c07', 'c08', 'c09', 'c10','academic', 'campus', 'internship']] #Train the model pca = PCA(n_components=0.8)# 80% explained variance pca.fit_transform(X) print("the number of extracted features we need: ", pca.n_components_)

pip install apyori

# Split the Electives column into separate columns for each course electives = StudentRecord['elective'].str.split(expand=True) electives.columns = ['elective_{}'.format(i+1) for i in range(electives.shape[1])] for column in electives.columns[electives.columns.str.startswith('elective_')]: electives[column] = electives[column].str.replace('[', '').str.replace(']', '').str.replace('\'', '').str.replace('`', '').astype('category') electives

# Converting courses to suitable format for apriori import ast StudentRecord['elective'] = StudentRecord['elective'].apply(lambda x: x.replace(" ", ",").replace("\n","")) electives = [x for x in StudentRecord['elective'].tolist()] electives = [ast.literal_eval(s) for s in electives] electives

from apyori import apriori # Setting the minimum support of 0.0050 rules = apriori(electives, min_support=0.0050, max_length=2) rules = list(rules) for j in range(10): antecedent = ",".join(list(rules[j].ordered_statistics[0].items_base)) consequent = ", ".join(list(rules[j].ordered_statistics[0].items_add)) support = round(rules[j].support, 5) confidence = round(rules[j].ordered_statistics[0].confidence, 5) lift = round(rules[j].ordered_statistics[0].lift, 5) print(f"Rule: {antecedent} --> {consequent}(Confidence: {confidence}, Support: {support}, Lift: {lift})\n")

# Setting min support 0.05 and min_confidence 0.5 ap_results = apriori(electives, min_support=0.05, min_length=2, min_confidence=0.5, min_lift=1.0) ap_results = list(ap_results) for result in ap_results: antecedent = ",".join(list(result.ordered_statistics[0].items_base)) consequent = ", ".join(list(result.ordered_statistics[0].items_add)) support = round(result.support, 5) confidence = round(result.ordered_statistics[0].confidence, 5) lift = round(result.ordered_statistics[0].lift, 5) print(f"Rule: {antecedent} --> {consequent}(Confidence: {confidence}, Support: {support}, Lift: {lift})\n")