Add files via upload

DfsApplication.java

@@ -0,0 +1,107 @@
+/*A group of connected 1's forms an island. The task is to complete the method findIslands() which returns the number of islands present. The function takes three arguments the first is the boolean matrix A and then the next two arguments are N and M denoting the size(N*M) of the matrix A .
+
+Input:
+The first line of input will be the number of testcases T, then T test cases follow. The first line of each testcase contains two space separated integers N and M. Then in the next line are the NxM inputs of the matrix A separated by space .
+
+Output:
+For each testcase in a new line, print the number of islands present.
+
+User Task:
+Since this is a functional problem you don't have to worry about input, you just have to complete the function findIslands().
+
+Constraints:
+1 <= T <= 100
+1 <= N, M <= 100
+0 <= A[i][j] <= 1
+
+Example(To be used only for expected output) :
+Input
+2
+3 3
+1 1 0 0 0 1 1 0 1
+4 4
+1 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0
+
+Output
+2
+2
+
+Explanation:
+Testcase 1: The graph will look like
+1 1 0
+0 0 1
+1 0 1
+Here, two islands will be formed
+First island will be formed by elements {A[0][0] ,  A[0][1], A[1][2], A[2][2]}
+Second island will be formed by {A[2][0]}.*/
+
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+
+class Driverclass {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+
+        while (t-- > 0) {
+            int N = sc.nextInt();
+            int M = sc.nextInt();
+
+            ArrayList<ArrayList<Integer>> list = new ArrayList<>(N);
+
+            // creating arraylist of arraylist
+            for (int i = 0; i < N; i++) {
+                ArrayList<Integer> temp = new ArrayList<>(M);
+                list.add(i, temp);
+            }
+
+            // adding elements to the arraylist of arraylist
+            for (int i = 0; i < N; i++) {
+                for (int j = 0; j < M; j++) {
+                    int val = sc.nextInt();
+                    list.get(i).add(j, val);
+                }
+            }
+
+            System.out.println(new Islands().findIslands(list, N, M));
+        }
+    }
+}
+
+
+
+
+class Islands {
+
+    // Function to find the number of island in the given list
+    // N, M: size of list row and column respectively
+    static int findIslands(ArrayList<ArrayList<Integer>> list, int N, int M) {
+
+        // Your code here
+        boolean[][] visit=new boolean[N][M];
+        int count=0;
+        for(int i=0;i<N;i++)
+            for(int j=0;j<M;j++)
+                if(list.get(i).get(j)==1 && visit[i][j]==false)
+                {
+                    dfs(list,i,j,visit,N,M);
+                    count+=1;
+                }
+        return count;
+    }
+    static void dfs(ArrayList<ArrayList<Integer>> list,int i,int j,boolean[][] visit, int N, int M)
+    {
+        visit[i][j]=true;
+        int[] rc=new int[]{-1,-1,-1,0,0,1,1,1};
+        int[] cc=new int[]{-1,0,1,-1,1,-1,0,1};
+        for(int k=0;k<8;k++)
+            if(isSafe(list,i+rc[k],j+cc[k],visit,N,M))
+                dfs(list,i+rc[k],j+cc[k],visit,N,M);
+    }
+    static boolean isSafe(ArrayList<ArrayList<Integer>> list,int i,int j,boolean[][] visit, int N, int M)
+    {
+        return i>=0&&i<N&&j>=0&&j<M&&list.get(i).get(j)==1&&visit[i][j]==false;
+    }
+}
+

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_
+
+
+
+
+
+
+
+
+
+