Add files via upload

ann.py

@@ -0,0 +1,152 @@
+# Artificial Neural Network
+
+# Installing Theano
+# pip install --upgrade --no-deps git+git://github.com/Theano/Theano.git
+
+# Installing Tensorflow
+# pip install tensorflow
+
+# Installing Keras
+# pip install --upgrade keras
+
+# Part 1 - Data Preprocessing
+
+# Importing the libraries
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+
+# Importing the dataset
+dataset = pd.read_csv('Churn_Modelling.csv')
+X = dataset.iloc[:, 3:13].values
+y = dataset.iloc[:, 13].values
+
+# Encoding categorical data
+from sklearn.preprocessing import LabelEncoder, OneHotEncoder
+labelencoder_X_1 = LabelEncoder()
+X[:, 1] = labelencoder_X_1.fit_transform(X[:, 1])
+labelencoder_X_2 = LabelEncoder()
+X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2])
+onehotencoder = OneHotEncoder(categorical_features = [1])
+X = onehotencoder.fit_transform(X).toarray()
+X = X[:, 1:]
+
+# Splitting the dataset into the Training set and Test set
+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, random_state = 0)
+
+# Feature Scaling
+from sklearn.preprocessing import StandardScaler
+sc = StandardScaler()
+X_train = sc.fit_transform(X_train)
+X_test = sc.transform(X_test)
+
+# Part 2 - Now let's make the ANN!
+
+# Importing the Keras libraries and packages
+import keras
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.layers import Dropout
+
+# Initialising the ANN
+classifier = Sequential()
+
+# Adding the input layer and the first hidden layer with dropout
+classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu', input_dim = 11))
+classifier.add(Dropout(p = 0.1))
+
+# Adding the second hidden layer
+classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu'))
+classifier.add(Dropout(p = 0.1))
+
+# Adding the output layer
+classifier.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid'))
+
+# Compiling the ANN
+classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
+
+# Fitting the ANN to the Training set
+classifier.fit(X_train, y_train, batch_size = 10, epochs = 100)
+
+# Part 3 - Making predictions and evaluating the model
+
+# Predicting the Test set results
+y_pred = classifier.predict(X_test)
+y_pred = (y_pred > 0.5)
+
+# Predicting a single new observation
+"""Predict if the customer with the following informations will leave the bank:
+Geography: France
+Credit Score: 600
+Gender: Male
+Age: 40
+Tenure: 3
+Balance: 60000
+Number of Products: 2
+Has Credit Card: Yes
+Is Active Member: Yes
+Estimated Salary: 50000"""
+new_prediction = classifier.predict(sc.transform(np.array([[0.0, 0, 600, 1, 40, 3, 60000, 2, 1, 1, 50000]])))
+new_prediction = (new_prediction > 0.5)
+
+# Making the Confusion Matrix
+from sklearn.metrics import confusion_matrix
+cm = confusion_matrix(y_test, y_pred)
+
+# Part 4 - Evaluating, Improving and Tuning the ANN
+
+# Evaluating the ANN
+from keras.wrappers.scikit_learn import KerasClassifier
+from sklearn.model_selection import cross_val_score
+from keras.models import Sequential
+from keras.layers import Dense
+def build_classifier():
+    classifier = Sequential()
+    classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu', input_dim = 11))
+    classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu'))
+    classifier.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid'))
+    classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
+    return classifier
+classifier = KerasClassifier(build_fn = build_classifier, batch_size = 10, epochs = 100)
+accuracies = cross_val_score(estimator = classifier, X = X_train, y = y_train, cv = 10, n_jobs = 1)
+mean = accuracies.mean()
+variance = accuracies.std()
+
+#Improving the ANN
+#Dropout Regularization to reduce overfitting if needed
+
+
+#Tuning the ANN
+from keras.wrappers.scikit_learn import KerasClassifier
+from sklearn.model_selection import GridSearchCV
+from keras.models import Sequential
+from keras.layers import Dense
+def build_classifier(optimizer):
+    classifier = Sequential()
+    classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu', input_dim = 11))
+    classifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu'))
+    classifier.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid'))
+    classifier.compile(optimizer = optimizer, loss = 'binary_crossentropy', metrics = ['accuracy'])
+    return classifier
+classifier = KerasClassifier(build_fn = build_classifier)
+parameters = {'batch_size' : [25, 32],
+              'nb_epochs' : [100, 500],
+              'optimizer' : ['adam', 'rmsprop']}
+grid_search = GridSearchCV(estimator = classifier,
+                           param_grid = parameters,
+                           scoring = 'accuracy',
+                           cv = 10)
+grid_search = grid_search.fit(X_train, y_train)
+best_parammeters = grid_search.best_params_
+best_accuracy = grid_search.best_score_
+
+
+
+
+
+
+
+
+
+

floydWarshal.cpp

@@ -0,0 +1,101 @@
+// Input:
+//        graph[][] = { {0,   5,  INF, 10},
+//                     {INF,  0,  3,  INF},
+//                     {INF, INF, 0,   1},
+//                     {INF, INF, INF, 0} }
+// which represents the following graph
+//              10
+//        (0)------->(3)
+//         |         /|\
+//       5 |          |
+//         |          | 1
+//        \|/         |
+//        (1)------->(2)
+//             3       
+// Note that the value of graph[i][j] is 0 if i is equal to j 
+// And graph[i][j] is INF (infinite) if there is no edge from vertex i to j.
+
+// Output:
+// Shortest distance matrix
+//       0      5      8      9
+//     INF      0      3      4
+//     INF    INF      0      1
+//     INF    INF    INF      0
+
+
+
+
+
+// C++ Program for Floyd Warshall Algorithm 
+#include <bits/stdc++.h> 
+using namespace std; 
+#define V 4 
+
+#define INF 99999 
+
+
+void printSolution(int dist[][V]); 
+
+void floydWarshall (int graph[][V]) 
+{ 
+
+	for (i = 0; i < V; i++) 
+		for (j = 0; j < V; j++) 
+			dist[i][j] = graph[i][j]; 
+
+
+	for (k = 0; k < V; k++) 
+	{ 
+		// Pick all vertices as source one by one 
+		for (i = 0; i < V; i++) 
+		{ 
+			// Pick all vertices as destination for the 
+			// above picked source 
+			for (j = 0; j < V; j++) 
+			{ 
+				// If vertex k is on the shortest path from 
+				// i to j, then update the value of dist[i][j] 
+				if (dist[i][k] + dist[k][j] < dist[i][j]) 
+					dist[i][j] = dist[i][k] + dist[k][j]; 
+			} 
+		} 
+	} 
+
+	// Print the shortest distance matrix 
+	printSolution(dist); 
+} 
+
+/* A utility function to print solution */
+void printSolution(int dist[][V]) 
+{ 
+	cout<<"The following matrix shows the shortest distances"
+			" between every pair of vertices \n"; 
+	for (int i = 0; i < V; i++) 
+	{ 
+		for (int j = 0; j < V; j++) 
+		{ 
+			if (dist[i][j] == INF) 
+				cout<<"INF"<<"	 "; 
+			else
+				cout<<dist[i][j]<<"	 "; 
+		} 
+		cout<<endl; 
+	} 
+} 
+
+// Driver code 
+int main() 
+{ 
+
+	int graph[V][V] = { {0, 5, INF, 10}, 
+						{INF, 0, 3, INF}, 
+						{INF, INF, 0, 1}, 
+						{INF, INF, INF, 0} 
+					}; 
+
+	// Print the solution 
+	floydWarshall(graph); 
+	return 0; 
+} 
+
+// This code is contributed by aanchal singh