{"cells":[{"metadata":{},"cell_type":"markdown","source":"Loading Dataset..Clean unused columns.."},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndf = pd.read_csv(\"../input/data.csv\")\nprint(df.info())\n#remove unused rows from data frame\ndf.drop([\"id\",\"Unnamed: 32\"],axis=1,inplace=True)","execution_count":35,"outputs":[{"output_type":"stream","text":"<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 569 entries, 0 to 568\nData columns (total 33 columns):\nid                         569 non-null int64\ndiagnosis                  569 non-null object\nradius_mean                569 non-null float64\ntexture_mean               569 non-null float64\nperimeter_mean             569 non-null float64\narea_mean                  569 non-null float64\nsmoothness_mean            569 non-null float64\ncompactness_mean           569 non-null float64\nconcavity_mean             569 non-null float64\nconcave points_mean        569 non-null float64\nsymmetry_mean              569 non-null float64\nfractal_dimension_mean     569 non-null float64\nradius_se                  569 non-null float64\ntexture_se                 569 non-null float64\nperimeter_se               569 non-null float64\narea_se                    569 non-null float64\nsmoothness_se              569 non-null float64\ncompactness_se             569 non-null float64\nconcavity_se               569 non-null float64\nconcave points_se          569 non-null float64\nsymmetry_se                569 non-null float64\nfractal_dimension_se       569 non-null float64\nradius_worst               569 non-null float64\ntexture_worst              569 non-null float64\nperimeter_worst            569 non-null float64\narea_worst                 569 non-null float64\nsmoothness_worst           569 non-null float64\ncompactness_worst          569 non-null float64\nconcavity_worst            569 non-null float64\nconcave points_worst       569 non-null float64\nsymmetry_worst             569 non-null float64\nfractal_dimension_worst    569 non-null float64\nUnnamed: 32                0 non-null float64\ndtypes: float64(31), int64(1), object(1)\nmemory usage: 146.8+ KB\nNone\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"Analyzing data.. And manupilating data depends on our needs.."},{"metadata":{"trusted":true},"cell_type":"code","source":"B = df[df.diagnosis==\"B\"]\nM = df[df.diagnosis==\"M\"]\nprint(\"Benign counts : \", B.shape)\nprint(\"Malignant counts : \",M.shape)\n\nplt.scatter(B.area_mean ,B.texture_mean,color=\"green\")\nplt.scatter(M.area_mean ,M.texture_mean,color=\"red\")\nplt.show()\n\n#Update diagnosis results with 1 and 0.Benign = 0 , Malignant= 1\ndf.diagnosis = [1 if each == \"M\" else 0 for each in df.diagnosis]\n\ny = df.iloc[:,0].values.reshape(-1,1)\nX = df.drop(\"diagnosis\",axis=1)\n\n#Normalization..\nX = (X - np.min(X)) / (np.max(X) - np.min(X)).values","execution_count":36,"outputs":[{"output_type":"stream","text":"Benign counts :  (357, 31)\nMalignant counts :  (212, 31)\n","name":"stdout"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"Sigmoid Function.. We are using sigmoid because bounderies of it limited between 0 and 1 and also has derivative."},{"metadata":{"trusted":true},"cell_type":"code","source":"def sigmoid(z) :\n    y_head = 1/(1+np.exp(-z))\n    return y_head","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Initializing weights and bias for first iteration with random values..This random values are intuitive.."},{"metadata":{"trusted":true},"cell_type":"code","source":"def initWeightsAndBias(size):\n    w = np.full((size,1),0.01)\n    b = 0.0\n    return w, b","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Calculation of forward propogation.\nWith forward propogation lets find z = w.T*x+b."},{"metadata":{"trusted":true},"cell_type":"code","source":"# z = w.T*x+b\ndef forwardPropogation (w,b,x_train,y_train,y_head):\n    v1 = -y_train*np.log(y_head)\n    v2 = (1-y_train)*np.log(1-y_head)\n    loss = v1-v2\n    cost = (np.sum(loss))/x_train.shape[1]      # divide to size of x_train for scaling\n    return cost","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Calculation of backward propogation with getting derivative of our function.."},{"metadata":{"trusted":true},"cell_type":"code","source":"def backwardPropogation (x_train,y_train,y_head):\n    calculated_weight = (np.dot(x_train,((y_head-y_train).T)))/x_train.shape[1]\n    calculated_bias = np.sum(y_head-y_train)/x_train.shape[1]\n    gradients = {\"calculated_weight\": calculated_weight,\"calculated_bias\": calculated_bias}\n    return gradients","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"For training our equation we should execute forward and backward simultaneously.."},{"metadata":{"trusted":true},"cell_type":"code","source":"def forwardBackwardPropagation(w,b,x_train,y_train):\n    z = np.dot(w.T,x_train) + b\n    y_head = sigmoid(z)\n    cost = forwardPropogation(w,b,x_train,y_train,y_head)\n    gradients = backwardPropogation(x_train,y_train,y_head)\n    return cost,gradients","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Now lets update our weights and bias with the values calculated after forward-backward propogation chain.."},{"metadata":{"trusted":true},"cell_type":"code","source":"def learn(w, b, x_train, y_train, learningRate,iteration):\n    costList = []\n    \n    for i in range(iteration):\n        # execute forward backward propogation to get updated gradients and cost\n        cost,gradients = forwardBackwardPropagation(w,b,x_train,y_train)\n        costList.append(cost)\n        # update weight and bias with the calculated values\n        w = w - learningRate * gradients[\"calculated_weight\"]\n        b = b - learningRate * gradients[\"calculated_bias\"]\n        #if (i % 100 == 0) :\n        #    print(\"w : {} - b : {} \".format(w,b) )\n        \n    # updated weights and bias\n    index = np.arange(iteration)\n    parameters = {\"weight\": w,\"bias\": b}\n    #print(\"Cost lists : \" , costList)\n    plt.plot(index,costList)\n    plt.xticks(index,rotation=90)\n    plt.xlabel(\" - Iteration Count - \")\n    plt.ylabel(\" - Cost - \")\n    plt.show()\n    return parameters, gradients, costList","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"let make predictions.."},{"metadata":{"trusted":true},"cell_type":"code","source":"def predict(w,b,x_test):\n    # make some prediction with test data..\n    z = sigmoid(np.dot(w.T,x_test)+b)\n    y_prediction = np.zeros((1,x_test.shape[1]))\n    \n    # Limit is 0.5. If predicted value is greater than 0.5 \n    # then i'll flag the tumor as a malignant otherwise i'll flag it as benign \n    # We can change limit value if its necessary..\n    for i in range(z.shape[1]):\n        if z[0,i]> 0.5:\n            y_prediction[0,i] = 1\n        \n\n    return y_prediction","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Lets check the accuracy for trained function.."},{"metadata":{"trusted":true},"cell_type":"code","source":"def logisticRegression(x_train, y_train, x_test, y_test, learningRate ,  iteration):\n    # initialize\n    size =  x_train.shape[0]\n    w,b = initWeightsAndBias(size)\n    parameters, grad, costList = learn(w, b, x_train, y_train, learningRate,iteration)\n    \n    y_test_predicted = predict(parameters[\"weight\"],parameters[\"bias\"],x_test)\n\n    # Calculate accuracy with test set..\n    print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(y_test_predicted - y_test)) * 100))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Creating training and test sets.. And train.."},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.model_selection import train_test_split\n\nx_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\nx_train = x_train.T\nx_test = x_test.T\ny_train = y_train.T\ny_test = y_test.T\n\n# print(\"x_train shape : \" ,x_train.shape)\n# print(\"x_test shape : \" ,x_test.shape)\n# print(\"y_train shape : \" ,y_train.shape)\n# print(\"y_test shape : \" ,y_test.shape)\n\n#Execute logistic regression for training..\nlogisticRegression(x_train, y_train, x_test, y_test,learningRate=1,iteration=150)","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.6.4","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":1}