import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn import metrics

import matplotlib.pyplot as plt

from sklearn import tree

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn import metrics

import matplotlib.pyplot as plt

from collections import Counter

from sklearn.metrics import confusion_matrix

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn import metrics

from sklearn.tree import export_graphviz

from six import StringIO

from IPython.display import Image

import pydotplus

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn import metrics

import numpy as np

import seaborn as sns

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn import metrics

from collections import Counter

import numpy as np

from sklearn.tree import DecisionTreeRegressor

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn import metrics

from collections import Counter

from sklearn.metrics import confusion_matrix

import numpy as np

from sklearn.metrics import accuracy_score

from sklearn.metrics import precision_recall_fscore_support

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn import metrics

from sklearn.tree import DecisionTreeRegressor

import pandas as pd

from sklearn.model_selection import train_test_split

import matplotlib.pyplot as plt

import numpy as np

from sklearn.tree import DecisionTreeRegressor

import pandas as pd

from sklearn import metrics

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.ensemble import RandomForestClassifier

import pandas as pd

from sklearn.model_selection import train_test_split

from collections import Counter

from sklearn.preprocessing import StandardScaler

from sklearn.linear_model import LogisticRegression

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn import metrics

import matplotlib.pyplot as plt

from collections import Counter

from sklearn.metrics import confusion_matrix

import seaborn as sns

from sklearn.ensemble import RandomForestClassifier

from sklearn.preprocessing import StandardScaler

from sklearn.linear_model import LogisticRegression

import statsmodels.api as sm

from sklearn.metrics import roc_auc_score

from sklearn.metrics import roc_curve

import matplotlib.pyplot as plt

import numpy as np

from numpy import array

from matplotlib.colors import ListedColormap

%matplotlib inline

import random

import matplotlib.pyplot as plt

from collections import Counter

import numpy as np

from sklearn import datasets

from sklearn.datasets import make_blobs

import matplotlib.pyplot as plt

import numpy as np

m, n = X.shape

bias = np.ones((X.shape[0], 1))

biased_X = np.hstack((bias, X))

random_gen = np.random.RandomState(1)

import matplotlib.pyplot as plt

import numpy as np

import pandas as pd

from sklearn.model_selection import train_test_split

from tensorflow.keras.layers import Dense

from tensorflow.keras import Sequential

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn import metrics

from collections import Counter

import seaborn as sns

from sklearn.metrics import accuracy_score

from tensorflow.keras.layers import Dense

from tensorflow.keras import Sequential

import pandas as pd

from sklearn.model_selection import train_test_split

from collections import Counter

import numpy as np

import seaborn as sns

from tensorflow.keras.layers import Dense

from tensorflow.keras import Sequential

from tensorflow.keras.utils import to_categorical

from sklearn.model_selection import train_test_split

import matplotlib.pyplot as plt

import numpy as np

%matplotlib inline

from keras.datasets import fashion_mnist

from keras.utils import to_categorical

from keras.models import Sequential, Model

from keras.layers import Dense, Dropout, Flatten

from keras.layers import Conv2D, MaxPooling2D

from keras.layers import LeakyReLU

import pandas as pd

import re

import re

import nltk

nltk.download("wordnet")

from nltk.corpus import wordnet

import requests

from lxml import html

import pandas as pd

from collections import Counter

import re

import nltk

import requests

from lxml import html

nltk.download('punkt')

from nltk.tokenize import word_tokenize

import pandas as pd

%matplotlib inline

import re

import nltk

import requests

from lxml import html

nltk.download('punkt')

from nltk.tokenize import word_tokenize

from nltk.probability import FreqDist

from bs4 import BeautifulSoup

nltk.download('stopwords')

from nltk.corpus import stopwords

golf = pd.read_csv('golf_nominal.csv', sep=';')

diabetes = pd.read_csv('diabetes_inbalanced.csv', index_col=0)

titanic = pd.read_csv('titanic.csv')

titanic = pd.read_csv('titanic.csv')

df = pd.read_csv('possum.csv')

diabetes = pd.read_csv('diabetes_inbalanced.csv', index_col=0)

df = pd.read_csv('ice_cream_data.csv', sep=";")

df = pd.read_csv('ice_cream_data.csv', sep=";")

titanic = pd.read_csv('titanic.csv')

df = pd.read_csv('Heart.csv')

df = pd.read_csv('Heart.csv')

url = "https://raw.githubusercontent.com/Statology/Python-Guides/main/default.csv"
data = pd.read_csv(url)

training_data = [
    (array([121,16.8]), 1),
    (array([114,15.2]), 1),
    (array([210,9.4]), -1),
    (array([195,8.1]), -1),
] 

training_data = [
    (array([3,-2]), -1),
    (array([3,1]), 1),
    (array([2,0]), -1),
] 

X, y = datasets.make_blobs(n_samples=100,n_features=2,
                           centers=2,cluster_std=1,
                           random_state=3) 

X, y = make_blobs(n_samples=400, n_features=3, centers=4, cluster_std=1, random_state=3)

mal_byt = np.array([1,2,3,4])
bol = np.array([1,0,2,5])

X, y = datasets.make_blobs(n_samples=100,n_features=2,
                           centers=2,cluster_std=1,
                           random_state=3) 

mal_byt = np.array([1,2,3,4])
bol = np.array([1,0,2,5])

x=np.array([[0,0,1,1],[0,1,0,1]])
print(x) 

y=np.array([[0,1,1,0]])
print(y) 

titanic = pd.read_csv('titanic.csv')

data = pd.read_csv('darts.csv')

vyber = data[(data.competitor == 'Michael') | (data.competitor == 'Steve')]

data = pd.read_csv('darts.csv')

(train_X,train_Y), (test_X,test_Y) = fashion_mnist.load_data()

text_file = open('human_rights.txt', 'r')

h_rights = text_file.read()

tweets = pd.read_csv("tweets.csv")

tweet = "@nltk T awesome! #regex #pandas #python"

text = "The cat is in the box. The cat likes the box. The box is over the cat."

X_train

X_test

osoba

X_train_scaled

X_train_scaled

biased_X[:4]

output_pred[:4]

errors[:4]

golf = pd.get_dummies(golf, columns = ["Outlook"], drop_first = False)

golf = pd.get_dummies(golf, columns = ["Temperature", "Humidity", "Windy"], drop_first = False)

titanic['Sex'] = titanic['Sex'].replace({'male': 0, 'female': 1})

titanic['Sex'] = titanic['Sex'].replace({'male': 0, 'female': 1})

osoba = osoba.reshape(1,-1)

df['Pop'] = df['Pop'].replace({'other': 0, 'Vic': 1})

df['sex'] = df['sex'].replace({'m': 0, 'f': 1})

df['sex'] = df['sex'].replace({'m': 0, 'f': 1})

df = df.drop(columns='Unnamed: 0')

df['ChestPain'] = df['ChestPain'].astype('category')
df['ChestPain'] = df['ChestPain'].cat.codes

df['Thal'] = df['Thal'].astype('category')
df['Thal'] = df['Thal'].cat.codes

df['AHD'] = df['AHD'].astype('category')
df['AHD'] = df['AHD'].cat.codes

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

df = df.drop(columns='Unnamed: 0')

df['ChestPain'] = df['ChestPain'].astype('category')
df['ChestPain'] = df['ChestPain'].cat.codes

df['Thal'] = df['Thal'].astype('category')
df['Thal'] = df['Thal'].cat.codes

df['AHD'] = df['AHD'].astype('category')
df['AHD'] = df['AHD'].cat.codes

X_train_scaled = scaler.fit_transform(X_train)

X_test_scaled = scaler.transform(X_test)

titanic['Sex'] = titanic['Sex'].replace({'male': 0, 'female': 1})

vyber['competitor'] = vyber['competitor'].replace({'Steve': 0, 'Michael': 1})

multi = data
multi["competitor"]=multi["competitor"].replace({'Steve':0,'Susan':1,'Michael':2,'Kate':3})

train_X = train_X.reshape(-1, 28,28, 1)
test_X = test_X.reshape(-1, 28,28, 1)
train_X.shape, test_X.shape

train_X = train_X.astype('float32')
test_X = test_X.astype('float32')
train_X = train_X / 255.
test_X = test_X / 255.

train_Y_one_hot = to_categorical(train_Y)
test_Y_one_hot = to_categorical(test_Y)
print('Original label:', train_Y[0])
print('After conversion to one-hot:', train_Y_one_hot[0])

X = golf[golf.columns.difference(['Play'])]
y = golf.Play

stlpce = golf[golf.columns.difference(['Play'])].columns.to_list()

stlpce

X = diabetes[diabetes.columns.difference(['Outcome'])]
y = diabetes['Outcome']
y=y.astype('int')

X = titanic[titanic.columns.difference(['Survived'])]
y = titanic['Survived']
y=y.astype('int')

X = titanic[titanic.columns.difference(['Survived'])]
y = titanic['Survived']
y=y.astype('int')

osoba = np.array([10, #age
                  0, #fare
                  0, #parent/children
                  1, #pclass
                  0, #sex
                  3]) #siblings/spouses

X = df[df.columns.difference(['age'])]
y = df['age']

X = diabetes[diabetes.columns.difference(['Outcome'])]
y = diabetes['Outcome']
y=y.astype('int')

X = df[df.columns.difference(['Revenue'])]
y = df['Revenue']

X = df.drop(['Revenue'], axis = 1)
y = df['Revenue']

X = df['Temperature'].values
y = df['Revenue'].values

vstup = df.drop(["Revenue"], axis=1)

X = titanic[titanic.columns.difference(['Survived'])]
y = titanic['Survived']
y=y.astype('int')

X = df.drop(columns = "AHD")
y = df['AHD']

X = df.drop(columns = "AHD")
y = df['AHD']

X = data[['student', 'balance', 'income']]
y = data['default']

X = titanic[titanic.columns.difference(['Survived'])]
y = titanic['Survived']
y=y.astype('int')

X = vyber[vyber.columns.difference(['competitor'])]
y = vyber['competitor']
y=y.astype('int')

X = vyber[vyber.columns.difference(['competitor'])]
y = vyber['competitor']
y=y.astype('int')

X = multi[multi.columns.difference(['competitor'])]
y = to_categorical(multi['competitor'])

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=21)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=21)

X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=0)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1)

train_X,valid_X,train_label,valid_label = train_test_split(train_X, train_Y_one_hot, test_size=0.2, random_state=13)

clf = DecisionTreeClassifier()

clf = DecisionTreeClassifier(criterion='gini')

clf = DecisionTreeClassifier(criterion='gini')

clf = DecisionTreeClassifier(criterion='entropy')

clf = DecisionTreeClassifier(random_state=0)

clf = DecisionTreeClassifier()

model = DecisionTreeRegressor()#max_depth=3)

clf = DecisionTreeClassifier()

regressor = DecisionTreeRegressor()

regressor = DecisionTreeRegressor()

rf_model = RandomForestClassifier()

rf_model = RandomForestClassifier(n_estimators=1000)

scaler = StandardScaler()

log_reg = LogisticRegression(random_state=0).fit(X_train_scaled, y_train)

scaler = StandardScaler()

log_reg = LogisticRegression(random_state=0).fit(X_train_scaled, y_train)

logit_model=sm.Logit(y, X)

log_regression = LogisticRegression()

rand_forest = RandomForestClassifier(random_state=0)

clf = DecisionTreeClassifier()

clf = clf.fit(X_train,y_train)

clf = clf.fit(X_train,y_train)

clf = clf.fit(X_train,y_train)

clf = clf.fit(X_train,y_train)

model.fit(X_train, y_train)

clf = clf.fit(X_train,y_train)

regressor.fit(X_train, y_train)

regressor.fit(X_train, y_train)

rf_model.fit(X_train, y_train)

rf_model.fit(X_train, y_train)

result=logit_model.fit()

log_regression.fit(X_train,y_train)

rand_forest.fit(X_test, y_test)

model.fit(X_train, y_train, epochs=50)

clf = clf.fit(X_train,y_train)

model.fit(X_train, y_train, epochs=200)

model.fit(X_train, y_train, epochs=200)

fashion_train = fashion_model.fit(train_X, train_label, batch_size=batch_size,epochs=epochs,verbose=1,validation_data=(valid_X, valid_label))

y_pred = clf.predict(X_test)

y_pred = clf.predict(X_test)

y_pred = clf.predict(X_test)

y_pred = clf.predict(X_test)

clf.predict(osoba)

predictions = model.predict(X_test)

model.predict([[0,33,63,28,55,14,65,95,0,4,55,36,93]])

y_pred = clf.predict(X_test)

y_pred = regressor.predict(X_test)

y_pred = regressor.predict(X_test)

y_pred = rf_model.predict(X_test)

rf_model.predict_proba(X_test)

rf_model.predict_log_proba(X_test)

log_reg.predict(X_train_scaled)

log_reg.predict_proba(X_test_scaled)

log_reg.predict_proba(X_test_scaled)

y_pred = log_reg.predict(X_test_scaled) 

print(log_regression.predict(X_test))

print(rand_forest.predict(X_train))

vstup_q = np.array([[-4,8]])
classifier.predict(vstup_q)

predictions = model.predict(X_test)

y_pred = model.predict(X_test).round()

y_pred = clf.predict(X_test)

predictions = model.predict(X_test)

y_pred = model.predict(X_test).round()

y_pred = model.predict(X_test).round()

print("Presnosť:",metrics.accuracy_score(y_test, y_pred))

print("Presnosť:",metrics.accuracy_score(y_test, y_pred))

confusion_matrix(y_test, y_pred, labels=[1,0])

print("Presnosť:",metrics.accuracy_score(y_test, y_pred))

clf.get_depth()

clf.get_n_leaves()

acc_gini

acc_entropy

d = pandas.DataFrame({'acc_gini':pandas.Series(acc_gini), 'acc_entropy':pandas.Series(acc_entropy), 'max_depth':pandas.Series(max_depth)})

data = pandas.DataFrame({'acc_train':pandas.Series(acc_train), 'acc_test':pandas.Series(acc_test), 'max_depth':pandas.Series(max_depth)})

path = clf.cost_complexity_pruning_path(X_train, y_train)

ccp_alphas, impurities = path.ccp_alphas, path.impurities

print("Presnosť:",metrics.accuracy_score(y_test, y_pred))

clf.get_depth()

clf.get_params()

predictions

confusion_matrix(y_test, y_pred, labels=[1,0])

accuracy_score(y_test, y_pred)

precision_recall_fscore_support(y_test, y_pred, labels=[1, 0])

p, r, f, s = precision_recall_fscore_support(y_test, y_pred)
cm = confusion_matrix(y_test, y_pred)

print('acc: ',metrics.accuracy_score(y_test, y_pred))
print('prec: ',((p[0]+p[1])/2),'(',p[0],' / ',p[1],')')
print('rec: ',((r[0]+r[1])/2),'(',r[0],' / ',r[1],')')
print('f1-sc:',((f[0]+f[1])/2))

print(confusion_matrix(y_test, y_pred)) 

d = pd.DataFrame({'Real Values':y_test, 'Predicted Values':y_pred})

d = pd.DataFrame({'Real Values':y_test, 'Predicted Values':y_pred})

d['sqr_res'] = pow((d['Real Values'] - d['Predicted Values']), 2)

d['sqr_res'].sum()

print("Presnosť:",metrics.accuracy_score(y_test, y_pred))

rf_model.get_params()

rf_model.feature_names_in_

log_reg.score(X_train_scaled, y_train)

log_reg.score(X_test_scaled, y_test)

print(result.summary2())

print('Accuracy of logistic regression classifier on test set: {:.2f}'.format(log_reg.score(X_test_scaled, y_test))) 

confusion_matrix = confusion_matrix(y_test, y_pred)
print(confusion_matrix) 

classification_report

print(classification_report(y_test, y_pred))

test = np.array([[0],[0]])
predict(w1,w2,test)
test = np.array([[1],[0]])
predict(w1,w2,test)
test = np.array([[0],[1]])
predict(w1,w2,test)
test = np.array([[1],[1]])
predict(w1,w2,test)

print("Presnosť:",metrics.accuracy_score(y_test, y_pred))

preds[:6]

y_test[:6]

print("Presnosť:",metrics.accuracy_score(y_test, y_pred))

predictions

labels_predict=np.argmax(y_pred,axis=1)
labels_predict[:6]

confusion_matrix(labels_predict, np.argmax(y_test, axis=1))

print("Presnost: ",metrics.accuracy_score(labels_predict, np.argmax(y_test, axis=1)))

test_eval = fashion_model.evaluate(test_X, test_Y_one_hot, verbose=0)

fig = plt.figure(figsize=(20,6))
_ = tree.plot_tree(clf, feature_names = stlpce, class_names=['no','yes'], filled=True)

fig = plt.figure(figsize=(20,6))
_ = tree.plot_tree(clf, feature_names = stlpce, class_names=['yes','no'], filled=True)

plt.figure(figsize=(40,20))
plot_tree(regressor, feature_names=vstup.columns.tolist())

diabetes.describe()

Counter(diabetes.Outcome)

df.info()

Counter(df.Pop)

Counter(df.sex)

diabetes.describe()

Counter(diabetes.Outcome)

corrMatrix = df.corr()

Counter(df.AHD)

df.isnull().sum()

corrMatrix = df.corr()

Counter(y)

X[:, :][y == 1] 

X.shape

Counter(vyber.competitor)

Counter(vyber.competitor)

data.shape

selected_part

print('Training data shape : ', train_X.shape, train_Y.shape)
print('Testing data shape : ', test_X.shape, test_Y.shape)

classes = np.unique(train_Y)
nClasses = len(classes)
print('Total number of outputs : ', nClasses)
print('Output classes : ', classes) 

train_X.shape,valid_X.shape,train_label.shape,valid_label.shape

h_rights

len(h_rights)

len(set(h_rights.split()))

max = 0
for w in slova:
    if len(w)>max:
        max = len(w)

tweets.head()

tweets['word_count'] = tweets.apply(lambda x: tweet_count(x), axis = 1)

tweets['char_count'] = tweets['tweet'].str.len()

tweets['avg_len'] = (tweets['char_count'] - (tweets['word_count'] - 1)) / tweets['word_count']

clf.decision_path(osoba).toarray()

def priamka(x):
    y = (W[0]*x + b)/(W[1]*(-1))
    return y 

def priamka(x):
    y = (W[0]*x + b)/(W[1]*(-1))
    return y 

model.summary()

model.summary()

model.summary()

fashion_model.summary()

fashion_model.save("fashion_model_dropout.h5")

plt.plot('max_depth','acc_gini', data=d, label='gini')
plt.plot('max_depth','acc_entropy', data=d, label='entropy')
plt.xlabel('max_depth')
plt.ylabel('accuracy')
plt.legend() 

plt.plot('max_depth','acc_train', data=data, marker='o', label='train')
plt.plot('max_depth','acc_test', data=data, marker='o', label='test')
plt.xlabel('max_depth')
plt.ylabel('accuracy')
plt.legend() 

fig, ax = plt.subplots()
ax.plot(ccp_alphas[:-1], impurities[:-1], marker="o", drawstyle="steps-post")
ax.set_xlabel("effective alpha")
ax.set_ylabel("total impurity of leaves")
ax.set_title("Total Impurity vs effective alpha for training set") 

plt.scatter(X_test, y_test, color='red')
plt.scatter(X_test, y_pred, color='green')
plt.title('Decision Tree Regression')
plt.xlabel('Temperature')
plt.ylabel('Revenue')
plt.show()

X_grid = np.arange(min(X), max(X), 0.01)
X_grid = X_grid.reshape((len(X_grid), 1))

plt.plot(X_grid, regressor.predict(X_grid), color='black')
plt.title('Decision Tree Regression')
plt.xlabel('Temperature')
plt.ylabel('Revenue')
plt.show()

sns.heatmap(corrMatrix, annot=True)
plt.show()

sns.heatmap(corrMatrix, annot=True)
plt.show()

sns.heatmap(corrMatrix, annot=True, fmt=".1f")
plt.show() 

plt.figure(figsize=(12, 9))
sn.heatmap(corrMatrix, annot=True)
plt.show()

logit_roc_auc = roc_auc_score(y_test, log_reg.predict(X_test_scaled))
fpr, tpr, thresholds = roc_curve(y_test, log_reg.predict_proba(X_test_scaled)[:,1])
plt.figure()
plt.plot(fpr, tpr, label='Logistic Regression (area = %0.2f)' % logit_roc_auc)
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.savefig('Log_ROC')
plt.show() 

y_pred = log_regression.predict_proba(X_test)[:, 1]
fpr, tpr, _ = metrics.roc_curve(y_test, y_pred)
auc = round(metrics.roc_auc_score(y_test, y_pred), 4)
plt.plot(fpr,tpr,label="Logistic Regression, AUC="+str(auc))

y_pred = rand_forest.predict_proba(X_test)[:, 1]
fpr, tpr, _ = metrics.roc_curve(y_test, y_pred)
auc = round(metrics.roc_auc_score(y_test, y_pred), 4)
plt.plot(fpr,tpr,label="Random Forest, AUC="+str(auc))
plt.legend() 

cm = plt.cm.RdBu
cm_bright = ListedColormap(['#FF0000', '#0000FF'])
ax = plt.subplot()
ax.set_title("Result")

for x, expected in training_data:
    if expected==1:
        vzor='r'
    else:

        vzor='b'
   # print(x[0])
    ax.scatter(x[0], x[1], color=vzor)

plt.plot([100,300],[priamka(100),priamka(300)])
plt.show() 

cm = plt.cm.RdBu
cm_bright = ListedColormap(['#FF0000', '#0000FF'])
ax = plt.subplot()
ax.set_title("Result")

for x, expected in training_data:
    if expected==1:
        vzor='r'
    else:
        vzor='b'    ax.scatter(x[0], x[1], color=vzor)

plt.plot([0,8],[priamka(0),priamka(8)])
plt.show() 

fig = plt.figure(figsize=(5,5))
plt.plot(X[:, 0][y == 0], X[:, 1][y == 0], 'r^')
plt.plot(X[:, 0][y == 1], X[:, 1][y == 1], 'bs')
plt.xlabel("feature 1")
plt.ylabel("feature 2")
plt.title('Random Classification Data with 2 classes') 

fig = plt.figure(figsize=(8, 6))

def vykresli_rozdelenie(X,Y,vahy,bias):
    print('kresli- vahy:',vahy,' bias:',bias)
    x1 = [min(X[:,0]), max(X[:,0])]
    x2 = [(priamka(x1[0],vahy,bias)),(priamka(x1[1],vahy,bias))]
    print('x1:',x1,'x2:',x2)
    fig = plt.figure(figsize=(8,5))
    plt.plot(X[:, 0][y==0], X[:, 1][y==0], "r^")
    plt.plot(X[:, 0][y==1], X[:, 1][y==1], "bs")
    plt.xlabel("feature 1")
    plt.ylabel("feature 2")
    plt.title('Perceptron')
    plt.plot(x1, x2, 'y-') 

plt.plot(range(1, len(classifier.cost) + 1), classifier.cost)
plt.title("Adaline: learn-rate 0.001")
plt.xlabel('Epochs')
plt.ylabel('Cost (Sum-of-Squares)')
plt.show()

plt.plot(losses)
plt.xlabel("EPOCHS")
plt.ylabel("Loss value")

sns.pairplot(data, hue='competitor')

sns.pairplot(data, hue='competitor')

plt.figure(figsize=[5,5])
plt.subplot(121)
plt.imshow(train_X[0,:,:], cmap='gray')
plt.title("Ground Truth : {}".format(train_Y[0]))
plt.subplot(122)
plt.imshow(test_X[0,:,:], cmap='gray')
plt.title("Ground Truth : {}".format(test_Y[0]))

accuracy = fashion_train.history['accuracy']
loss = fashion_train.history['loss']
val_loss = fashion_train.history['val_loss']
epochs = range(len(accuracy))
plt.plot(epochs, accuracy, 'bo', label='Training accuracy')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()

df = df.dropna()

df = df.dropna()

golf

golf.head()

diabetes

titanic

titanic.head()

df.head()

max_depth = []
acc_gini = []
acc_entropy = []
for i in range(1,30):
    dtree = DecisionTreeClassifier(criterion='gini', max_depth=i)
    dtree.fit(X_train, y_train)
    pred = dtree.predict(X_test)
    acc_gini.append(metrics.accuracy_score(y_test, pred))
 ####
    dtree = DecisionTreeClassifier(criterion='entropy', max_depth=i)
    dtree.fit(X_train, y_train)
    pred = dtree.predict(X_test)
    acc_entropy.append(metrics.accuracy_score(y_test, pred))
 ####
    max_depth.append(i)

max_depth = []
acc_test = []
acc_train = []
for i in range(1,101):
    dtree = DecisionTreeClassifier(criterion='gini', max_depth=i)
    dtree.fit(X_train, y_train)

    pred_train = dtree.predict(X_train)
    pred_test = dtree.predict(X_test)

    acc_train.append(metrics.accuracy_score(y_train, pred_train))
    acc_test.append(metrics.accuracy_score(y_test, pred_test))
 ####
    max_depth.append(i)

def aktivacna_fn(x):
    if x>=0:
        return 1
    else:
        return -1 

def neuron(X,W,b):
 return  aktivacna_fn(np.dot(X,W) + b) 

W = array([-30,300])
b = -1230
eta = 0.01
print('aktualne vahy: ' , W)
print('bias: ', b) 

for i in range(0, 4):
    print('---')
    x, y = training_data[i]
    print('trenovacie data: ' , x , ', vysledok: ', y)

    predikcia = neuron(x,W,b)
    print('predikcia: ',predikcia)
    chyba = y - predikcia
    if (chyba != 0):
        print('potrebne je upravit vahy')
        W = W + (eta * chyba * x)
        b = b + (eta * chyba * 1)
    print('aktualne vahy: ' , W)
    print('bias: ', b) 

vektor = array ([100, 10])
neuron(vektor, W, b)

r1 = random.randint(-100, 100)
r2 = random.randint(-100, 100)
W = array([r1,r2])
b = random.randint(-100, 100)
eta = 0.5
print('aktualne vahy: ' , W)
print('bias: ', b) 

uprava_vahy = True
epocha_id = 1

while uprava_vahy:
  print('epocha: ', epocha_id)
  epocha_id += 1
  uprava_vahy = False
  for i in range(0, 3):
    print('---')
    x, y = training_data[i]
    predikcia = neuron(x,W,b)    chyba = y - predikcia    if (chyba != 0):
        uprava_vahy = True
        W = W + (eta * chyba * x)
        b = b + (eta * chyba * 1)
    print('aktualne vahy: ' , W, ', bias: ', b) 

def aktivacna_fn(x):
    if x>=0:
        return 1
    else:
        return -1 

def neuron(X,W,b):
 return  aktivacna_fn(np.dot(X,W) + b) 

vahy = np.zeros((n+1, 2))

def perceptron(X, Y, eta, epochs):
    m, n = X.shape
    W = np.zeros(n)
    b = 0
    for epoch in range(epochs):
      print('epocha: ',epoch)
      vykresli_rozdelenie(X,Y,W,b)
      for i in range(0, m):
        x = X[i]
        y = Y[i]
        predikcia = neuron(x,W,b)
        chyba = y - predikcia
        if (chyba != 0):
          W = W + (eta * chyba * x)
          b = b + (eta * chyba * 1) 

perceptron(X, y, 0.5, 10)

def sum_squared_errors(y, output_pred):
    errors = y - output_pred
    return (errors**2).sum()/2.0

sum_squared_errors(mal_byt, bol)

def vnutorny_potencial(X, weights):
    return np.dot(X, weights)

def sum_squared_errors(y, output_pred):
    errors = y - output_pred
    return (errors**2).sum()/2.0

sum_squared_errors(mal_byt, bol)

def vnutorny_potencial(X, weights):
    return np.dot(X, weights)

def aktivacna_fn(x):
    return x 

weights = random_gen.normal(loc = 0.0, scale = 0.01, size = biased_X.shape[1]) 

cost = []
learn_rate = 0.5
output_pred = aktivacna_fn(vnutorny_potencial(biased_X, weights)) 

errors = y - output_pred

weights += (learn_rate * biased_X.T.dot(errors))

weights

cost_i = (errors**2).sum() /2.0
cost_i = sum_squared_errors(y,output_pred)

for i in range(20):
  output_pred = aktivacna_fn(vnutorny_potencial(biased_X, weights))
  errors = y - output_pred
  weights += (learn_rate * biased_X.T.dot(errors))
  cost_i = (errors**2).sum() / 2.0
  cost.append(cost_i)

class Adaline(object):

    def __init__(self, learn_rate = 0.001, iterations = 10000):
        self.learn_rate = learn_rate
        self.iterations = iterations

    def fit(self, X, y, biased_X = False, standardised_X = False):
        if not standardised_X:
            X = self._standardise_features(X)
        if not biased_X:
            X = self._add_bias(X)
        self._initialise_weights(X)
        self.cost = []

        for cycle in range(self.iterations):
            output_pred = self._activation(self._net_input(X))
            errors = y - output_pred
            self.weights += (self.learn_rate * X.T.dot(errors))
            cost = (errors**2).sum() / 2.0
            self.cost.append(cost)
        return self

    def _net_input(self, X):
        return np.dot(X, self.weights)

    def predict(self, X, biased_X=False):
        if not biased_X:
            X = self._add_bias(X)
        return np.where(self._activation(self._net_input(X)) >= 0.0, 1, 0)

    def _add_bias(self, X):
        bias = np.ones((X.shape[0], 1))
        biased_X = np.hstack((bias, X))
        return biased_X

    def _initialise_weights(self, X):
        random_gen = np.random.RandomState(1)
        self.weights = random_gen.normal(loc = 0.0, scale = 0.01, size = X.shape[1])
        return self

    def _standardise_features(self, X):
        X_norm = (X - np.mean(X, axis=0)) / np.std(X, axis = 0)
        return X_norm

    def _activation(self, X):
        return X 

classifier = Adaline(learn_rate = 0.001, iterations = 100)
a = classifier.fit(X, y)

a.weights

n_x = 2
n_h = 2
n_y = 1
m = x.shape[1]
lr = 0.2
np.random.seed(2)
w1 = np.random.rand(n_h,n_x)   # vahova matica pre skrytu vrstvu
w2 = np.random.rand(n_y,n_h)   # vahova matica pre vystupnu vrstvu
losses = [] 

def sigmoid(z):
    z= 1/(1+np.exp(-z))
    return z

def forward_prop(w1,w2,x):
    z1 = np.dot(w1,x)
    a1 = sigmoid(z1)
    z2 = np.dot(w2,a1)
    a2 = sigmoid(z2)
    return z1,a1,z2,a2

def back_prop(m,w1,w2,z1,a1,z2,a2,y):
    dz2 = a2-y
    dw2 = np.dot(dz2,a1.T)/m
    dz1 = np.dot(w2.T,dz2) * a1*(1-a1)
    dw1 = np.dot(dz1,x.T)/m
    dw1 = np.reshape(dw1,w1.shape)

    dw2 = np.reshape(dw2,w2.shape)
    return dz2,dw2,dz1,dw1

iterations = 100000
for i in range(iterations):
    z1,a1,z2,a2 = forward_prop(w1,w2,x)
    loss = -(1/m)*np.sum(y*np.log(a2)+(1-y)*np.log(1-a2))
    losses.append(loss)

    da2,dw2,dz1,dw1 = back_prop(m,w1,w2,z1,a1,z2,a2,y)
    w2 = w2-lr*dw2
    w1 = w1-lr*dw1

def predict(w1,w2,input):
    z1,a1,z2,a2 = forward_prop(w1,w2,test)
    a2 = np.squeeze(a2)
    if a2>=0.5:
        print("For input", [i[0] for i in input], "output is 1")
    else:
        print("For input", [i[0] for i in input], "output is 0")

model = Sequential()
model.add(Dense(48,input_shape=(6,),activation="sigmoid"))
model.add(Dense(6,activation="sigmoid"))
model.add(Dense(1))

model.compile(optimizer="adam", loss="mse") 

model.compile(optimizer="adam", loss="mse") 

model = Sequential()
model.add(Dense(4,input_shape=(2,),activation="relu"))
model.add(Dense(1))

model = Sequential()
model.add(Dense(4,input_shape=(2,),activation="relu"))
model.add(Dense(4,activation="softmax"))

model.compile(optimizer="adam", loss="binary_crossentropy")

batch_size = 64
epochs = 5
num_classes = 10

fashion_model = Sequential()
fashion_model.add(Conv2D(32, kernel_size=(3, 3),activation='linear',input_shape=(28,28,1),padding='same'))
fashion_model.add(LeakyReLU(alpha=0.1))
fashion_model.add(MaxPooling2D((2, 2),padding='same'))
fashion_model.add(Conv2D(64, (3, 3), activation='linear',padding='same'))
fashion_model.add(LeakyReLU(alpha=0.1))
fashion_model.add(MaxPooling2D(pool_size=(2, 2),padding='same'))
fashion_model.add(Conv2D(128, (3, 3), activation='linear',padding='same'))
fashion_model.add(LeakyReLU(alpha=0.1))
fashion_model.add(MaxPooling2D(pool_size=(2, 2),padding='same'))
fashion_model.add(Flatten())
fashion_model.add(Dense(128, activation='linear'))
fashion_model.add(LeakyReLU(alpha=0.1))
fashion_model.add(Dense(num_classes, activation='softmax'))

fashion_model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adam(),metrics=['accuracy'])

x = lambda a: a + 100

h_rights = h_rights.replace('\n', ' ')
h_rights = h_rights.replace("\ufeff", ' ')
h_rights = h_rights.replace(',', ' ')
h_rights = h_rights.replace('.', ' ')

slova = h_rights.split()

def tweet_count(row):
    my_var = row['tweet']
    return len(my_var.split())

re.match('abc','abcdefgh')

re.search('#[A-Za-z0-9]+', tweet)

[w for w in tweet.split() if re.search('#[A-Za-z0-9]+', w)]

sentence1 = "In the beginning was the Word"
re.findall("b.+ing", sentence1)

sent = 'My email is jkapusta@ukf.sk and my colleague has mdrlik@ukf.sk . This is the bad email: jkkkapusta@u.k'
[w for w in sent.split(" ") if re.search("[a-z]+@[a-z.]+.[a-z]{2,3}$",w)]

syns = wordnet.synsets('joy')

for syn in syns[0].lemmas():
    print(syn.name())

for syn in syns:
    for lema in syn.lemmas():
        print(lema.name())

syns[0].definition()

slovo = "joy"
synonyma = []
antonyma = []

for syn in wordnet.synsets(slovo):
    for lema in syn.lemmas():
        synonyma.append(lema.name())
        if lema.antonyms():
            antonyma.append(lema.antonyms()[0].name())
print('Synonymá:')
print(set(synonyma))
print('Antonymá:')
print(set(antonyma)) 

w1 = wordnet.synset('joy.n.01')
w2 = wordnet.synset('joyousness.n.01')
print(w1.wup_similarity(w2))

w1 = wordnet.synset('joy.n.01')
w2 = wordnet.synset('mouse.n.01')
print(w1.wup_similarity(w2))

[w for w in sent.split('"') if re.search("^[a-zA-Z0-9+-_.]{1,64}@[a-zA-Z0-9-]{1,255}\.[a-zA-Z0-9-.]{2,}$", w)]

array = word_tokenize(text)

smalym = text.lower()

word_tokenize(smalym)

v = Counter(word_tokenize(smalym))

v.most_common(5)

words = word_tokenize(all_titles)

text_lower = [w.lower() for w in words]

freq = FreqDist(text_lower)

freq.most_common(10)

tokenizer = nltk.tokenize.RegexpTokenizer('\w+')

tokens = tokenizer.tokenize(text)

words = []
for word in tokens:
    words.append(word.lower())

freq = FreqDist(words)

sw = stopwords.words('english')

words_ns = []
for word in words:
    if word not in sw: words_ns.append(word)

freqdist = nltk.FreqDist(words_ns)

freqdist.plot(20, cumulative=False)

link = "https://ukf.sk"
stranka = requests.get(link)
stranka.text

tree = html.fromstring(stranka.content)

nazvy = tree.xpath("//h2/a/text()")

link2 = "https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2334524.m570.l1313&_nkw=iphone+15&_sacat=0&_odkw=iphone&_osacat=0"
stranka2 = requests.get(link2)

tree2 = html.fromstring(stranka2.content)
prices = []
for item in tree2.xpath('//span[@class="s-item__price"]'):
    price_text = item.text_content()
    price_match = re.search(r'\$\d+(?:,\d{3})*(?:\.\d{2})?', price_text)
    if price_match:
        price = float(price_match.group().replace('$', '').replace(',', ''))
        prices.append(price)
        print(prices)

if prices:
    average_price = sum(prices) / len(prices)
    print(f"Average price of iPhone on Ebay: ${average_price:.2f}")
else:
    print("No prices found.")

link3 = "https://www.ebay.com/sch/i.html?_from=R40&_trksid=p2334524.m570.l1313&_nkw=iphone+15&_sacat=0&_odkw=iphone&_osacat=0"
stranka3 = requests.get(link3)
tree3 = html.fromstring(stranka3.content)
ceny3 = tree3.xpath('//div/span[@class="s-item__price"]/text()')
ceny3[:5]

ceny_nove = []
for c in ceny3:
    new_c = c.strip()
    new_c = new_c.replace(",","")
    if len(new_c)>1:
        ceny_nove.append(float(new_c[1:]))

link = "http://www.tu.ff.ukf.sk/kontakty"
stranka = requests.get(link)
sent = stranka.text

tree = html.fromstring(stranka.content)

link = "https://sacred-texts.com/cla/aesop/index.htm"
stranka = requests.get(link)
stranka.text

nazvy = tree.xpath("//body/a/text()")

all_titles = ''
for title in nazvy:
  all_titles += ' ' + title 

result_all = tree.xpath("//a/@href")

vsetko = ""
for odkaz in result_all:
    link = 'https://sacred-texts.com/cla/aesop/' + odkaz

    my_content = requests.get(link)
    result_all = tree.xpath("//hr/p/text()")
    for title in result_all:
        all_titles += '' + title
        vsetko = vsetko + " " + result_all

r = requests.get('http://www.gutenberg.org/files/2701/2701-h/2701-h.htm')

r.encoding = 'utf-8'

html = r.text

print(html[:200])

soup = BeautifulSoup(html, 'html.parser')

text = soup.get_text()

data = plt.imread('stop.jfif')
plt.imshow(data)

selected_part = data[100:150 , 10:100 , : ]
plt.imshow(selected_part)

variation_img = data[: , : , 0]
plt.imshow(variation_img)

selected_part = data[100:103 , 10:16 , : ]
plt.imshow(selected_part)

data_gray = np.mean(data, axis=2)
plt.imshow(data_gray, cmap='gray')
plt.show()