Amazing-Python-Scripts

1
{
2
  "nbformat": 4,
3
  "nbformat_minor": 0,
4
  "metadata": {
5
    "colab": {
6
      "provenance": []
7
    },
8
    "kernelspec": {
9
      "name": "python3",
10
      "display_name": "Python 3"
11
    },
12
    "language_info": {
13
      "name": "python"
14
    }
15
  },
16
  "cells": [
17
    {
18
      "cell_type": "code",
19
      "execution_count": null,
20
      "metadata": {
21
        "colab": {
22
          "base_uri": "https://localhost:8080/"
23
        },
24
        "id": "3OdAmKlHK9Os",
25
        "outputId": "f783297e-692c-4b88-f282-2ae61e370bec"
26
      },
27
      "outputs": [
28
        {
29
          "output_type": "stream",
30
          "name": "stdout",
31
          "text": [
32
            "Logistic regression\n",
33
            "83.6734693877551\n",
34
            "0.4287427131192695\n",
35
            "              precision    recall  f1-score   support\n",
36
            "\n",
37
            "         0.0       0.67      0.40      0.50        10\n",
38
            "         1.0       0.86      0.95      0.90        39\n",
39
            "\n",
40
            "    accuracy                           0.84        49\n",
41
            "   macro avg       0.76      0.67      0.70        49\n",
42
            "weighted avg       0.82      0.84      0.82        49\n",
43
            "\n"
44
          ]
45
        }
46
      ],
47
      "source": [
48
        "import pandas\n",
49
        "from sklearn.model_selection import train_test_split\n",
50
        "from sklearn.metrics import matthews_corrcoef\n",
51
        "from sklearn.metrics import classification_report\n",
52
        "from sklearn.neighbors import KNeighborsClassifier\n",
53
        "from sklearn.preprocessing import MinMaxScaler\n",
54
        "from sklearn.metrics import accuracy_score\n",
55
        "from sklearn.model_selection import KFold\n",
56
        "from sklearn.model_selection import cross_val_score\n",
57
        "from sklearn.linear_model import LogisticRegression\n",
58
        "from sklearn.tree import DecisionTreeClassifier, export_graphviz\n",
59
        "from sklearn.neighbors import KNeighborsClassifier\n",
60
        "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
61
        "from sklearn.naive_bayes import GaussianNB\n",
62
        "from sklearn.neural_network import MLPClassifier\n",
63
        "from sklearn.preprocessing import MinMaxScaler\n",
64
        "from sklearn.ensemble import GradientBoostingClassifier\n",
65
        "from sklearn.metrics import accuracy_score\n",
66
        "\n",
67
        "\n",
68
        "\n",
69
        "url = \"data.csv\"\n",
70
        "# feature names\n",
71
        "features = [\"MDVP:Fo(Hz)\",\"MDVP:Fhi(Hz)\",\"MDVP:Flo(Hz)\",\"MDVP:Jitter(%)\",\"MDVP:Jitter(Abs)\",\"MDVP:RAP\",\"MDVP:PPQ\",\"Jitter:DDP\",\"MDVP:Shimmer\",\"MDVP:Shimmer(dB)\",\"Shimmer:APQ3\",\"Shimmer:APQ5\",\"MDVP:APQ\",\"Shimmer:DDA\",\"NHR\",\"HNR\",\"RPDE\",\"DFA\",\"spread1\",\"spread2\",\"D2\",\"PPE\",\"status\"]\n",
72
        "dataset = pandas.read_csv(url, names=features)\n",
73
        "\n",
74
        "\n",
75
        "array = dataset.values\n",
76
        "scaler = MinMaxScaler(feature_range=(0,1))\n",
77
        "scaled = scaler.fit_transform(array)\n",
78
        "\n",
79
        "X = scaled[:,0:22]\n",
80
        "\n",
81
        "Y = scaled[:,22]\n",
82
        "validation_size = 0.25\n",
83
        "\n",
84
        "seed = 7\n",
85
        "\n",
86
        "X_train, X_validation, Y_train, Y_validation = train_test_split(X, Y, test_size=validation_size, random_state=seed)\n",
87
        "\n",
88
        "\n",
89
        "num_folds = 10\n",
90
        "num_instances = len(X_train)\n",
91
        "\n",
92
        "scoring = 'accuracy'\n",
93
        "\n",
94
        "results = []\n",
95
        "clf = LogisticRegression()\n",
96
        "kfold = KFold(n_splits=num_folds, shuffle=True, random_state=seed)\n",
97
        "cv_results = cross_val_score(clf, X_train, Y_train, cv=kfold, scoring=scoring)\n",
98
        "clf.fit(X_train, Y_train)\n",
99
        "\n",
100
        "\n",
101
        "\n",
102
        "\n",
103
        "predictions = clf.predict(X_validation)\n",
104
        "print(\"Logistic regression\")\n",
105
        "print(accuracy_score(Y_validation, predictions)*100)\n",
106
        "acc1 = accuracy_score(Y_validation, predictions) * 100\n",
107
        "print(matthews_corrcoef(Y_validation, predictions))\n",
108
        "print(classification_report(Y_validation, predictions))\n"
109
      ]
110
    },
111
    {
112
      "cell_type": "code",
113
      "source": [
114
        "url = \"data.csv\"\n",
115
        "\n",
116
        "features = [\"MDVP:Fo(Hz)\",\"MDVP:Fhi(Hz)\",\"MDVP:Flo(Hz)\",\"MDVP:Jitter(%)\",\"MDVP:Jitter(Abs)\",\"MDVP:RAP\",\"MDVP:PPQ\",\"Jitter:DDP\",\"MDVP:Shimmer\",\"MDVP:Shimmer(dB)\",\"Shimmer:APQ3\",\"Shimmer:APQ5\",\"MDVP:APQ\",\"Shimmer:DDA\",\"NHR\",\"HNR\",\"RPDE\",\"DFA\",\"spread1\",\"spread2\",\"D2\",\"PPE\",\"status\"]\n",
117
        "dataset = pandas.read_csv(url, names=features)\n",
118
        "\n",
119
        "array = dataset.values\n",
120
        "scaler = MinMaxScaler(feature_range=(0,1))\n",
121
        "scaled = scaler.fit_transform(array)\n",
122
        "\n",
123
        "X = scaled[:,0:22]\n",
124
        "\n",
125
        "Y = scaled[:,22]\n",
126
        "validation_size = 0.25\n",
127
        "\n",
128
        "seed = 7\n",
129
        "\n",
130
        "X_train, X_validation, Y_train, Y_validation = train_test_split(X, Y, test_size=validation_size, random_state=seed)\n",
131
        "\n",
132
        "\n",
133
        "num_folds = 10\n",
134
        "num_instances = len(X_train)\n",
135
        "\n",
136
        "\n",
137
        "scoring = 'accuracy'\n",
138
        "\n",
139
        "results = []\n",
140
        "clf = KNeighborsClassifier()\n",
141
        "kfold = KFold(n_splits=num_folds, shuffle=True, random_state=seed)\n",
142
        "cv_results = cross_val_score(clf, X_train, Y_train, cv=kfold, scoring=scoring)\n",
143
        "clf.fit(X_train, Y_train)\n",
144
        "predictions = clf.predict(X_validation)\n",
145
        "print(\"K-Nearest Neighbour\")\n",
146
        "print(accuracy_score(Y_validation, predictions)*100)\n",
147
        "acc2 = accuracy_score(Y_validation, predictions) * 100\n",
148
        "print(matthews_corrcoef(Y_validation, predictions))\n",
149
        "print(classification_report(Y_validation, predictions))"
150
      ],
151
      "metadata": {
152
        "colab": {
153
          "base_uri": "https://localhost:8080/"
154
        },
155
        "id": "gVK1a2hksWf0",
156
        "outputId": "fad5f0c6-a1df-45f6-fb37-dd9ddbab9ee1"
157
      },
158
      "execution_count": null,
159
      "outputs": [
160
        {
161
          "output_type": "stream",
162
          "name": "stdout",
163
          "text": [
164
            "K-Nearest Neighbour\n",
165
            "97.95918367346938\n",
166
            "0.9367496997597597\n",
167
            "              precision    recall  f1-score   support\n",
168
            "\n",
169
            "         0.0       1.00      0.90      0.95        10\n",
170
            "         1.0       0.97      1.00      0.99        39\n",
171
            "\n",
172
            "    accuracy                           0.98        49\n",
173
            "   macro avg       0.99      0.95      0.97        49\n",
174
            "weighted avg       0.98      0.98      0.98        49\n",
175
            "\n"
176
          ]
177
        }
178
      ]
179
    },
180
    {
181
      "cell_type": "code",
182
      "source": [
183
        "import pandas\n",
184
        "from pandas.plotting import scatter_matrix\n",
185
        "from sklearn.model_selection import train_test_split, KFold, cross_val_score\n",
186
        "from sklearn.metrics import matthews_corrcoef, classification_report, confusion_matrix, accuracy_score\n",
187
        "from sklearn.neural_network import MLPClassifier\n",
188
        "from sklearn.preprocessing import MinMaxScaler\n",
189
        "\n",
190
        "\n",
191
        "url = \"data.csv\"\n",
192
        "\n",
193
        "features = [\"MDVP:Fo(Hz)\",\"MDVP:Fhi(Hz)\",\"MDVP:Flo(Hz)\",\"MDVP:Jitter(%)\",\"MDVP:Jitter(Abs)\",\"MDVP:RAP\",\"MDVP:PPQ\",\"Jitter:DDP\",\"MDVP:Shimmer\",\"MDVP:Shimmer(dB)\",\"Shimmer:APQ3\",\"Shimmer:APQ5\",\"MDVP:APQ\",\"Shimmer:DDA\",\"NHR\",\"HNR\",\"RPDE\",\"DFA\",\"spread1\",\"spread2\",\"D2\",\"PPE\",\"status\"]\n",
194
        "dataset = pandas.read_csv(url, names=features)\n",
195
        "\n",
196
        "\n",
197
        "array = dataset.values\n",
198
        "scaler = MinMaxScaler(feature_range=(0, 1))\n",
199
        "scaled = scaler.fit_transform(array)\n",
200
        "\n",
201
        "X = scaled[:, 0:22]\n",
202
        "\n",
203
        "Y = scaled[:, 22]\n",
204
        "validation_size = 0.25\n",
205
        "\n",
206
        "seed = 7\n",
207
        "\n",
208
        "X_train, X_validation, Y_train, Y_validation = train_test_split(X, Y, test_size=validation_size, random_state=seed)\n",
209
        "\n",
210
        "\n",
211
        "num_folds = 10\n",
212
        "scoring = 'accuracy'\n",
213
        "\n",
214
        "results = []\n",
215
        "clf = MLPClassifier(solver='lbfgs')\n",
216
        "kfold = KFold(n_splits=num_folds, shuffle=True, random_state=seed)\n",
217
        "cv_results = cross_val_score(clf, X_train, Y_train, cv=kfold, scoring=scoring)\n",
218
        "clf.fit(X_train, Y_train)\n",
219
        "predictions = clf.predict(X_validation)\n",
220
        "print(\"NN MLP classifier\")\n",
221
        "print(\"Accuracy:\", accuracy_score(Y_validation, predictions) * 100)\n",
222
        "acc3 = accuracy_score(Y_validation, predictions) * 100\n",
223
        "print(\"MCC:\", matthews_corrcoef(Y_validation, predictions))\n",
224
        "print(classification_report(Y_validation, predictions))\n"
225
      ],
226
      "metadata": {
227
        "colab": {
228
          "base_uri": "https://localhost:8080/"
229
        },
230
        "id": "NZ49anQ0R1f4",
231
        "outputId": "1c9c35ff-cf85-44c0-a0d4-c95f852d24ef"
232
      },
233
      "execution_count": null,
234
      "outputs": [
235
        {
236
          "output_type": "stream",
237
          "name": "stdout",
238
          "text": [
239
            "NN MLP classifier\n",
240
            "Accuracy: 95.91836734693877\n",
241
            "MCC: 0.8743589743589744\n",
242
            "              precision    recall  f1-score   support\n",
243
            "\n",
244
            "         0.0       0.90      0.90      0.90        10\n",
245
            "         1.0       0.97      0.97      0.97        39\n",
246
            "\n",
247
            "    accuracy                           0.96        49\n",
248
            "   macro avg       0.94      0.94      0.94        49\n",
249
            "weighted avg       0.96      0.96      0.96        49\n",
250
            "\n"
251
          ]
252
        }
253
      ]
254
    },
255
    {
256
      "cell_type": "code",
257
      "source": [
258
        "url = \"data.csv\"\n",
259
        "\n",
260
        "features = [\"MDVP:Fo(Hz)\",\"MDVP:Fhi(Hz)\",\"MDVP:Flo(Hz)\",\"MDVP:Jitter(%)\",\"MDVP:Jitter(Abs)\",\"MDVP:RAP\",\"MDVP:PPQ\",\"Jitter:DDP\",\"MDVP:Shimmer\",\"MDVP:Shimmer(dB)\",\"Shimmer:APQ3\",\"Shimmer:APQ5\",\"MDVP:APQ\",\"Shimmer:DDA\",\"NHR\",\"HNR\",\"RPDE\",\"DFA\",\"spread1\",\"spread2\",\"D2\",\"PPE\",\"status\"]\n",
261
        "dataset = pandas.read_csv(url, names=features)\n",
262
        "\n",
263
        "array = dataset.values\n",
264
        "scaler = MinMaxScaler(feature_range=(0,1))\n",
265
        "scaled = scaler.fit_transform(array)\n",
266
        "\n",
267
        "X = scaled[:,0:22]\n",
268
        "\n",
269
        "Y = scaled[:,22]\n",
270
        "validation_size = 0.25\n",
271
        "\n",
272
        "seed = 7\n",
273
        "X_train, X_validation, Y_train, Y_validation = train_test_split(X, Y, test_size=validation_size, random_state=seed)\n",
274
        "\n",
275
        "\n",
276
        "num_folds = 10\n",
277
        "num_instances = len(X_train)\n",
278
        "\n",
279
        "scoring = 'accuracy'\n",
280
        "\n",
281
        "models = []\n",
282
        "models.append(('Decision tree', DecisionTreeClassifier()))\n",
283
        "\n",
284
        "\n",
285
        "results = []\n",
286
        "names = []\n",
287
        "for name, model in models:\n",
288
        "  kfold = KFold(n_splits=num_folds,shuffle=True, random_state=seed)\n",
289
        "  cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)\n",
290
        "  results.append(cv_results)\n",
291
        "  names.append(name)\n",
292
        "  model.fit(X_train, Y_train)\n",
293
        "  predictions = model.predict(X_validation)\n",
294
        "  print(name, accuracy_score(Y_validation, predictions)*100)\n",
295
        "  acc4 = accuracy_score(Y_validation, predictions) * 100\n",
296
        "  print(matthews_corrcoef(Y_validation, predictions))\n",
297
        "  print('----------------------')\n",
298
        "  export_graphviz(model, out_file=\"tree.dot\")"
299
      ],
300
      "metadata": {
301
        "colab": {
302
          "base_uri": "https://localhost:8080/"
303
        },
304
        "id": "iaB2Es8vuprO",
305
        "outputId": "94c871e8-7a51-4c69-f5a0-4c7bd4c35126"
306
      },
307
      "execution_count": null,
308
      "outputs": [
309
        {
310
          "output_type": "stream",
311
          "name": "stdout",
312
          "text": [
313
            "Decision tree 95.91836734693877\n",
314
            "0.8743589743589744\n",
315
            "----------------------\n"
316
          ]
317
        }
318
      ]
319
    },
320
    {
321
      "cell_type": "code",
322
      "source": [
323
        "import pandas\n",
324
        "from pandas.plotting import scatter_matrix\n",
325
        "from sklearn.model_selection import train_test_split\n",
326
        "from sklearn.metrics import matthews_corrcoef\n",
327
        "from sklearn.metrics import classification_report\n",
328
        "from sklearn.metrics import confusion_matrix\n",
329
        "from sklearn.linear_model import LogisticRegression\n",
330
        "from sklearn.tree import DecisionTreeClassifier, export_graphviz\n",
331
        "from sklearn.neighbors import KNeighborsClassifier\n",
332
        "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
333
        "from sklearn.naive_bayes import GaussianNB\n",
334
        "from sklearn.neural_network import MLPClassifier\n",
335
        "from sklearn.preprocessing import MinMaxScaler\n",
336
        "from sklearn.ensemble import GradientBoostingClassifier\n",
337
        "from sklearn.metrics import accuracy_score\n",
338
        "\n",
339
        "\n",
340
        "\n",
341
        "\n",
342
        "features = [\"MDVP:Fo(Hz)\",\"MDVP:Fhi(Hz)\",\"MDVP:Flo(Hz)\",\"MDVP:Jitter(%)\",\"MDVP:Jitter(Abs)\",\"MDVP:RAP\",\"MDVP:PPQ\",\"Jitter:DDP\",\"MDVP:Shimmer\",\"MDVP:Shimmer(dB)\",\"Shimmer:APQ3\",\"Shimmer:APQ5\",\"MDVP:APQ\",\"Shimmer:DDA\",\"NHR\",\"HNR\",\"RPDE\",\"DFA\",\"spread1\",\"spread2\",\"D2\",\"PPE\",\"status\"]\n",
343
        "dataset = pandas.read_csv(\"data.csv\", names=features)\n",
344
        "\n",
345
        "array = dataset.values\n",
346
        "scaler = MinMaxScaler(feature_range=(0,1))\n",
347
        "scaled = scaler.fit_transform(array)\n",
348
        "\n",
349
        "X = scaled[:,0:22]\n",
350
        "\n",
351
        "Y = scaled[:,22]\n",
352
        "validation_size = 0.25\n",
353
        "\n",
354
        "seed = 7\n",
355
        "X_train, X_validation, Y_train, Y_validation = train_test_split(X, Y, test_size=validation_size, random_state=seed)\n",
356
        "\n",
357
        "\n",
358
        "num_folds = 10\n",
359
        "num_instances = len(X_train)\n",
360
        "scoring = 'accuracy'\n",
361
        "\n",
362
        "\n",
363
        "models = []\n",
364
        "models.append(('Gradient Boosting', GradientBoostingClassifier(n_estimators=1000)))\n",
365
        "\n",
366
        "\n",
367
        "results = []\n",
368
        "names = []\n",
369
        "for name, model in models:\n",
370
        "  kfold = KFold(n_splits=num_folds,shuffle=True, random_state=seed)\n",
371
        "  cv_results = cross_val_score(model, X_train, Y_train, cv=kfold, scoring=scoring)\n",
372
        "  results.append(cv_results)\n",
373
        "  names.append(name)\n",
374
        "  model.fit(X_train, Y_train)\n",
375
        "  predictions = model.predict(X_validation)\n",
376
        "  print(name, accuracy_score(Y_validation, predictions)*100)\n",
377
        "  acc5 = accuracy_score(Y_validation, predictions) * 100\n",
378
        "  print(matthews_corrcoef(Y_validation, predictions))"
379
      ],
380
      "metadata": {
381
        "colab": {
382
          "base_uri": "https://localhost:8080/"
383
        },
384
        "id": "gfE7kgCWqZum",
385
        "outputId": "00035706-2d0c-4820-fed3-a637af5ba8f1"
386
      },
387
      "execution_count": null,
388
      "outputs": [
389
        {
390
          "output_type": "stream",
391
          "name": "stdout",
392
          "text": [
393
            "Gradient Boosting 95.91836734693877\n",
394
            "0.8723391598203635\n"
395
          ]
396
        }
397
      ]
398
    },
399
    {
400
      "cell_type": "code",
401
      "source": [
402
        "from sklearn.feature_selection import SelectPercentile, chi2\n",
403
        "percentile = 70  # Select top 50% of features\n",
404
        "selector = SelectPercentile(score_func=chi2, percentile=percentile)\n",
405
        "\n",
406
        "# Apply feature selection to the training data\n",
407
        "X_train_selected = selector.fit_transform(X_train, Y_train)\n",
408
        "\n",
409
        "# Get the indices of the selected features\n",
410
        "selected_feature_indices = selector.get_support(indices=True)\n",
411
        "\n",
412
        "# Print the selected feature indices\n",
413
        "print(\"Selected feature indices:\", selected_feature_indices)\n"
414
      ],
415
      "metadata": {
416
        "colab": {
417
          "base_uri": "https://localhost:8080/"
418
        },
419
        "id": "V7nDCPdWUSdT",
420
        "outputId": "18aea6e1-6089-4ff5-9cb2-fa0beaaacf0b"
421
      },
422
      "execution_count": null,
423
      "outputs": [
424
        {
425
          "output_type": "stream",
426
          "name": "stdout",
427
          "text": [
428
            "Selected feature indices: [ 0  2  3  4  5  6  8  9 10 11 12 13 18 19 21]\n"
429
          ]
430
        }
431
      ]
432
    },
433
    {
434
      "cell_type": "code",
435
      "source": [
436
        "import matplotlib.pyplot as plt\n",
437
        "import seaborn as sns\n",
438
        "\n",
439
        "\n",
440
        "acc = [acc1,acc2,acc3,acc4,acc5]\n",
441
        "mod = ['LR','kNN','MLP','DT','GB']\n",
442
        "\n",
443
        "\n",
444
        "plt.plot(mod, acc, marker='o')\n",
445
        "\n",
446
        "plt.xlabel('Model')\n",
447
        "plt.ylabel('Accuracy')\n",
448
        "plt.title('Accuracy of Different Models')\n",
449
        "\n",
450
        "plt.show()"
451
      ],
452
      "metadata": {
453
        "id": "9OVYQd2KtW4a",
454
        "colab": {
455
          "base_uri": "https://localhost:8080/",
456
          "height": 472
457
        },
458
        "outputId": "59560b55-2338-4cd7-9684-4b01df5626b1"
459
      },
460
      "execution_count": null,
461
      "outputs": [
462
        {
463
          "output_type": "display_data",
464
          "data": {
465
            "text/plain": [
466
              "<Figure size 640x480 with 1 Axes>"
467
            ],
468
            "image/png": "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\n"
469
          },
470
          "metadata": {}
471
        }
472
      ]
473
    },
474
    {
475
      "cell_type": "code",
476
      "source": [],
477
      "metadata": {
478
        "id": "9vbCoHJM893r"
479
      },
480
      "execution_count": null,
481
      "outputs": []
482
    }
483
  ]
484
}