The Wahyudiharto's Blog

How to Create Text to Speech from Google Colab using gTTS Library

noreply@blogger.com (Eko Wahyudiharto) — Tue, 05 Oct 2021 07:36:00 +0000

Google Text-to-Speech (gTTS) is one of several text-to-speech library available to used on Google Colab. It has simple code and reliable to use with, for example it also provide a simple language parameter so the speech out depend on what country id will be used. Don't forget to add audio player library since gTTS will create an audio file on-the-fly and need the audio player to make a sound. Check a compact code below and run it from Google Colab:

!pip install gTTS
from gtts import gTTS
from IPython.display import Audio

tts = gTTS('Selamat datang di channel youtube eko wahyudiharto',lang='id')
tts.save('1.wav')
sound_file = '1.wav'
Audio(sound_file, autoplay=True)

I wrapped above code into a 5 mins video below in my Youtube channel (in Bahasa). Please subscribe if you haven't or send your thumbs for the video or share it if you like.

PS: Still unable how to play a loop string in a 'for' syntax. Anyone can help? Share your thoughts on below comment box. Thank you!

Tutorial Indonesian Natural Language Processing using Sastrawi | Google Colab Python

noreply@blogger.com (Eko Wahyudiharto) — Sun, 19 Sep 2021 10:52:00 +0000

Definition of terms:

Sastrawi is a simple PHP library that allows you to reduce inflected words in Indonesian (Bahasa Indonesia) to their basic form (stem).

Cleansing is an activity to improve data systematically using certain algorithms.

Stemming is the process of changing affixed words into root words.

Tokenizing is the process of dividing text, which can be in the form of sentences, paragraphs or documents, into certain tokens/parts. Tokenization is often used in linguistics and the tokenization results are useful for further text analysis.

Stop-words are common words that usually appear in large numbers and are considered meaningless. Stop words are commonly used in information retrieval tasks, including by Google.

Source:

import requests
import string
import re

from bs4 import BeautifulSoup
import nltk
from nltk.corpus import stopwords

!pip install Sastrawi
from Sastrawi.Stemmer.StemmerFactory import StemmerFactory

web = requests.get('https://wartakota.tribunnews.com/').text
soup = BeautifulSoup(web)
for s in soup(['script', 'style']):
        s.decompose()
teks = ' '.join(soup.stripped_strings)
print (teks)

teks = teks.lower()
teks = re.sub(r"\d+", "", teks) #remove number
teks = teks.translate(str.maketrans("","",string.punctuation)) #remove punctuation
teks = teks.strip() #remove empty character

factory = StemmerFactory()
stemmer = factory.create_stemmer()
output   = stemmer.stem(teks)
print (output)

tokens = [t for t in output.split()]
print(tokens)

nltk.download()
clean_tokens = tokens[:]
for token in tokens:
if token in stopwords.words('indonesian'):
      clean_tokens.remove(token)

freq = nltk.FreqDist(clean_tokens)
for key,val in freq.items():
print(str(key) + ':' + str(val))

freq.plot(30)

And I wrapped them all into single video below:

Please support this blog or my video channel with subscribe button or like & share if you like it.

Python - Dimension Reduction – Self Organizing Maps (SOM)

noreply@blogger.com (Eko Wahyudiharto) — Sun, 25 Jul 2021 05:49:00 +0000

Data:

Employees when they sent job applicant (40 rows)

Mission:

How to visualize data mapping using SOM algorithm

Library used:

Pandas

Scikit

SimpSOM

Code:

import pandas as pd

from sklearn.preprocessing import StandardScaler

!pip install SimpSOM

import SimpSOM as sps

url = 'https://raw.githubusercontent.com/kokocamp/vlog119/main/vlog119.csv'

vlog139 = pd.read_csv(url)

X = vlog139[['gpa','gmat','work_experience','admitted']]

y = vlog139['admitted']

scaler = StandardScaler()

data = scaler.fit_transform(pd.DataFrame(X))

labels = scaler.fit_transform(pd.DataFrame(y))

print(data)

net = sps.somNet(50, 50, data)

#Train the network for 10000 epochs and with initial learning rate of 0.1.

net.train(0.01, 1000)

#Print a map of the network nodes and colour them according to the first feature (column number 0) of the dataset

#and then according to the distance between each node and its neighbours.

net.nodes_graph()

net.diff_graph()

#Project the datapoints on the new 2D network map.

net.project(data, labels=labels)

#Cluster the datapoints according to the Quality Threshold algorithm.

net.cluster(data)

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Dimension Reduction – Generative Adversarial Model (GAN)

noreply@blogger.com (Eko Wahyudiharto) — Sun, 25 Jul 2021 05:46:00 +0000

Data:

Salary list from job position (11 rows)

Mission:

How to generate data prediction from current existing data

Library used:

Matplotlib

Numpy

Pandas

PyTorch

Code:

import matplotlib.pyplot as plt

import numpy as np

import pandas as pd

import torch

from torch import nn

class Discriminator(nn.Module):

    def __init__(self):

        super().__init__()

        self.model = nn.Sequential(

            nn.Linear(2, 256),

            nn.ReLU(),

            nn.Dropout(0.3),

            nn.Linear(256, 128),

            nn.ReLU(),

            nn.Dropout(0.3),

            nn.Linear(128, 64),

            nn.ReLU(),

            nn.Dropout(0.3),

            nn.Linear(64, 1),

            nn.Sigmoid(),

        )

    def forward(self, x):

        output = self.model(x)

        return output

discriminator = Discriminator()

class Generator(nn.Module):

    def __init__(self):

        super().__init__()

        self.model = nn.Sequential(

            nn.Linear(2, 16),

            nn.ReLU(),

            nn.Linear(16, 32),

            nn.ReLU(),

            nn.Linear(32, 2),

        )

    def forward(self, x):

        output = self.model(x)

        return output

generator = Generator()

url = 'https://raw.githubusercontent.com/kokocamp/vlog120/main/vlog120.csv'

vlog138 = pd.read_csv(url)

print(vlog138)

X = vlog138['Level']

y = vlog138['Gaji']

tensor_X = torch.from_numpy(X.values)

tensor_y = torch.from_numpy(y.values)

train_data_length = 10

train_data = torch.zeros((train_data_length, 2))

train_data[:, 0] = tensor_X

train_data[:, 1] = tensor_y

train_labels = torch.zeros(train_data_length)

train_set = [

    (train_data[i], train_labels[i]) for i in range(train_data_length)

]

plt.plot(train_data[:, 0], train_data[:, 1], ".")

#==============================

batch_size = 10

train_loader = torch.utils.data.DataLoader(

    train_set, batch_size=batch_size, shuffle=True

)

#==============================

lr = 0.001

num_epochs = 10

loss_function = nn.BCELoss()

optimizer_discriminator = torch.optim.Adam(discriminator.parameters(), lr=lr)

optimizer_generator = torch.optim.Adam(generator.parameters(), lr=lr)

for epoch in range(num_epochs):

    for n, (real_samples, _) in enumerate(train_loader):

        # Data for training the discriminator

        real_samples_labels = torch.ones((batch_size, 1))

        latent_space_samples = torch.randn((batch_size, 2))

        generated_samples = generator(latent_space_samples)

        generated_samples_labels = torch.zeros((batch_size, 1))

        all_samples = torch.cat((real_samples, generated_samples))

        all_samples_labels = torch.cat(

            (real_samples_labels, generated_samples_labels)

        )

        # Training the discriminator

        discriminator.zero_grad()

        output_discriminator = discriminator(all_samples)

        loss_discriminator = loss_function(output_discriminator, all_samples_labels)

        loss_discriminator.backward()

        optimizer_discriminator.step()

        # Data for training the generator

        latent_space_samples = torch.randn((batch_size, 2))

        # Training the generator

        generator.zero_grad()

        generated_samples = generator(latent_space_samples)

        output_discriminator_generated = discriminator(generated_samples)

        loss_generator = loss_function(

            output_discriminator_generated, real_samples_labels

        )

        loss_generator.backward()

        optimizer_generator.step()

        # Show loss

        if epoch % 10 == 0 and n == batch_size - 1:

            print(f"Epoch: {epoch} Loss D.: {loss_discriminator}")

            print(f"Epoch: {epoch} Loss G.: {loss_generator}")

==============================

latent_space_samples = torch.randn(10, 2)

generated_samples = generator(latent_space_samples)

generated_samples = generated_samples.detach()

plt.plot(generated_samples[:, 0], generated_samples[:, 1], ".")

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Dimension Reduction – Hebbian Learning

noreply@blogger.com (Eko Wahyudiharto) — Sun, 25 Jul 2021 05:43:00 +0000

Data:

Employees when they sent job applicant (40 rows)

Mission:

How to predict the probability of someone will accepted from given gpa, gmat & work_experience

Library used:

Numpy

Pandas

Scikit

Neupy

Code:

import numpy as np

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.metrics import accuracy_score

!pip install neupy

from neupy import algorithms

url = 'https://raw.githubusercontent.com/kokocamp/vlog119/main/vlog119.csv'

vlog136 = pd.read_csv(url)

vlog136.describe()

X = vlog136[['gpa','gmat','work_experience']]

y = vlog136['admitted']

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

sc = StandardScaler()

X_train = sc.fit_transform(X_train)

X_test = sc.transform(X_test)

hebbnet = algorithms.HebbRule(

    n_inputs=3,

    n_outputs=1,

    n_unconditioned=1,

    step=0.1,

    decay_rate=0.2,

    verbose=True

)

hebbnet.train(X_train, epochs=10)

y_pred = hebbnet.predict(X_test)

print(y_pred)

print('Accuracy : '+str(accuracy_score(y_test, y_pred)))

new_candidates = {'gpa': [2,3.7,3.3,2.3,3],

                  'gmat': [590,740,680,610,710],

                  'work_experience': [3,4,6,1,5]

                  }

df2 = pd.DataFrame(new_candidates,columns= ['gpa','gmat','work_experience'])

df2 = sc.transform(df2)

y_pred=hebbnet.predict(df2)

print (df2)

print (y_pred)

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Dimension Reduction – Auto Encoder

noreply@blogger.com (Eko Wahyudiharto) — Sun, 25 Jul 2021 05:40:00 +0000

Data:

Employees when they sent job applicant (40 rows)

Mission:

Accuracy comparison experiment between Auto Encoder and K-Nearest Neighbours (KNN), Decision Tree, Naïve Bayes, Support Vector Machine

Library used:

Pandas

Numpy

Matplotlib

Seaborn

Scikit

Keras

Code:

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.manifold import TSNE

from sklearn.preprocessing import MinMaxScaler

from sklearn.metrics import accuracy_score

from keras.layers import Input, Dense

from keras.models import Model, Sequential

from keras import regularizers

from sklearn.linear_model import LogisticRegression

from sklearn.neighbors import KNeighborsClassifier

from sklearn.tree import DecisionTreeClassifier

from sklearn.naive_bayes import GaussianNB

from sklearn.svm import SVC

url = 'https://raw.githubusercontent.com/kokocamp/vlog119/main/vlog119.csv'

vlog135 = pd.read_csv(url)

vlog135.describe()

X = vlog135[['gpa','gmat','work_experience']]

y = vlog135['admitted']

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

tsne = TSNE(n_components = 3, random_state = 0)

X_tsne = tsne.fit_transform(X)

plt.scatter(X_tsne[np.where(y == 0), 0],

                X_tsne[np.where(y == 0), 1],

                marker ='o', color ='y', linewidth ='1',

                alpha = 0.8, label ='Gagal')

plt.scatter(X_tsne[np.where(y == 1), 0],

                X_tsne[np.where(y == 1), 1],

                marker ='o', color ='k', linewidth ='1',

                alpha = 0.8, label ='Lulus')

plt.legend()

plt.show()

X_skala = MinMaxScaler().fit_transform(X)

X_gagal_skala = X_skala[y == 0]

X_lulus_skala = X_skala[y == 1]

# Building the Input Layer

input_layer = Input(shape =(X.shape[1], ))

# Building the Encoder network

encoded = Dense(100, activation ='tanh',

                activity_regularizer = regularizers.l1(10e-5))(input_layer)

encoded = Dense(50, activation ='tanh',

                activity_regularizer = regularizers.l1(10e-5))(encoded)

encoded = Dense(25, activation ='tanh',

                activity_regularizer = regularizers.l1(10e-5))(encoded)

encoded = Dense(12, activation ='tanh',

                activity_regularizer = regularizers.l1(10e-5))(encoded)

encoded = Dense(6, activation ='relu')(encoded)

# Building the Decoder network

decoded = Dense(12, activation ='tanh')(encoded)

decoded = Dense(25, activation ='tanh')(decoded)

decoded = Dense(50, activation ='tanh')(decoded)

decoded = Dense(100, activation ='tanh')(decoded)

# Building the Output Layer

output_layer = Dense(X.shape[1], activation ='relu')(decoded)

# Defining the parameters of the Auto-encoder network

autoencoder = Model(input_layer, output_layer)

autoencoder.compile(optimizer ="adadelta", loss ="mse")

# Training the Auto-encoder network

autoencoder.fit(X_lulus_skala, X_lulus_skala,

                batch_size = 16, epochs = 10,

                shuffle = True, validation_split = 0.25)

hidden_representation = Sequential()

hidden_representation.add(autoencoder.layers[0])

hidden_representation.add(autoencoder.layers[1])

hidden_representation.add(autoencoder.layers[2])

hidden_representation.add(autoencoder.layers[3])

hidden_representation.add(autoencoder.layers[4])

# Separating the points encoded by the Auto-encoder as normal and fraud

gagal_hidden_rep = hidden_representation.predict(X_gagal_skala)

lulus_hidden_rep = hidden_representation.predict(X_lulus_skala)

# Combining the encoded points into a single table

encoded_X = np.append(gagal_hidden_rep, lulus_hidden_rep, axis = 0)

y_gagal = np.zeros(gagal_hidden_rep.shape[0])

y_lulus = np.ones(lulus_hidden_rep.shape[0])

encoded_y = np.append(y_gagal, y_lulus)

# Plotting the encoded points

#tsne_plot(encoded_X, encoded_y)

tsne = TSNE(n_components = 2, random_state = 0)

X_tsne = tsne.fit_transform(encoded_X)

plt.scatter(X_tsne[np.where(encoded_y == 0), 0],

                X_tsne[np.where(encoded_y == 0), 1],

                marker ='o', color ='y', linewidth ='1',

                alpha = 0.8, label ='Gagal')

plt.scatter(X_tsne[np.where(encoded_y == 1), 0],

                X_tsne[np.where(encoded_y == 1), 1],

                marker ='o', color ='k', linewidth ='1',

                alpha = 0.8, label ='Lulus')

plt.legend()

plt.show()

# Splitting the encoded data for linear classification

X_train_encoded, X_test_encoded, y_train_encoded, y_test_encoded = train_test_split(encoded_X, encoded_y, test_size = 0.25)

# Splitting the original data for non-linear classification

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

# Building the logistic regression model

logistic_regression = LogisticRegression()

logistic_regression.fit(X_train_encoded, y_train_encoded)

# Storing the predictions of the linear model

y_pred_logistic_regression = logistic_regression.predict(X_test_encoded)

# Evaluating the performance of the linear model

print('Accuracy : '+str(accuracy_score(y_test_encoded, y_pred_logistic_regression)))

knn = KNeighborsClassifier()

knn.fit(X_train, y_train)

# Storing the predictions of the non-linear model

y_pred_knn = knn.predict(X_test)

# Evaluating the performance of the non-linear model

print('Accuracy : '+str(accuracy_score(y_test, y_pred_knn)))

d3 = DecisionTreeClassifier()

d3.fit(X_train, y_train)

# Storing the predictions of the non-linear model

y_pred_d3 = d3.predict(X_test)

# Evaluating the performance of the non-linear model

print('Accuracy : '+str(accuracy_score(y_test, y_pred_d3)))

nb = GaussianNB()

nb.fit(X_train, y_train)

# Storing the predictions of the non-linear model

y_pred_nb = nb.predict(X_test)

# Evaluating the performance of the non-linear model

print('Accuracy : '+str(accuracy_score(y_test, y_pred_nb)))

# Building the SVM model

svm = SVC()

svm.fit(X_train, y_train)

# Storing the predictions of the non-linear model

y_pred_svm = svm.predict(X_test)

# Evaluating the performance of the non-linear model

print('Accuracy : '+str(accuracy_score(y_test, y_pred_svm)))

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Dimension Reduction – Anomaly Detection (Outlier Detection)

noreply@blogger.com (Eko Wahyudiharto) — Sun, 25 Jul 2021 05:37:00 +0000

Data:

Employees when they sent job applicant (40 rows)

Mission:

How to find & learn about data anomaly from graphic output result

Library used:

Pandas

Numpy

Matplotlib

Seaborn

Scikit

PyOD

Code:

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt (#5)

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.decomposition import PCA

from sklearn.preprocessing import StandardScaler

!pip install pyod

from pyod.utils.data import get_outliers_inliers

from pyod.models.pca import PCA

from pyod.utils.data import evaluate_print

from pyod.utils.example import visualize

url = 'https://raw.githubusercontent.com/kokocamp/vlog119/main/vlog119.csv'

vlog134 = pd.read_csv(url)

vlog134.describe()

X = vlog134[['gpa', 'gmat','work_experience']]

y = vlog134['admitted']

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

X_train = pd.DataFrame(X_train)

X_train['y'] = y_train

X_test = pd.DataFrame(X_test)

X_test['y'] = y_test

X_train.head()

sc = StandardScaler()

X_train = sc.fit_transform(X_train)

df_train = pd.DataFrame(X_train)

X_test = sc.fit_transform(X_test)

df_test = pd.DataFrame(X_test)

sns.scatterplot(x=df_train[0], y=df_train[1], hue=df_train[3], data=df_train)

plt.title('Ground Truth')

pca = PCA(n_components=3)

pca.fit(X_train)

y_train_pred = pca.labels_

y_train_scores = pca.decision_scores_

sns.scatterplot(x=df_train[0], y=df_train[1], hue=y_train_scores, data=df_train, palette='RdBu_r');

plt.title('Skor Anomali PCA');

axes = df_train.plot(subplots=True, figsize=(16, 8), title='Simulated Anomaly Data for Training');

plt.show()

axes = df_test.plot(subplots=True, figsize=(16, 8), title='Simulated Anomaly Data for Test');

plt.show()

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Dimension Reduction - Principal Componen Analysis (PCA)

noreply@blogger.com (Eko Wahyudiharto) — Sun, 25 Jul 2021 05:30:00 +0000

Data:

Employees when they sent job applicant (40 rows)

Mission:

How to predict the probability of someone will accepted from given gpa, gmat & work_experience

Library used:

Pandas

Scikit

Seaborn

Code:

import pandas as pd

from sklearn.model_selection import train_test_split

from sklearn.linear_model import LogisticRegression

from sklearn import metrics

import seaborn as sn

from sklearn.decomposition import PCA

from sklearn.preprocessing import StandardScaler

url = 'https://raw.githubusercontent.com/kokocamp/vlog119/main/vlog119.csv'

vlog133 = pd.read_csv(url)

vlog133.describe()

X = vlog133[['gpa', 'gmat','work_experience']]

y = vlog133['admitted']

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

sn.scatterplot(x="gpa",y="admitted",data=vlog133,color="red",alpha=0.5)

sc = StandardScaler()

X_train = sc.fit_transform(X_train)

X_test = sc.transform(X_test)

pca = PCA(n_components=3)

X_train = pca.fit_transform(X_train)

X_test = pca.transform(X_test)

logistic_regression= LogisticRegression()

logistic_regression.fit(X_train,y_train)

y_pred=logistic_regression.predict(X_test)

confusion_matrix = pd.crosstab(y_test, y_pred, rownames=['Actual'], colnames=['Predicted'])

sn.heatmap(confusion_matrix, annot=True)

print('Accuracy: ',metrics.accuracy_score(y_test, y_pred))

print (X_test) #test dataset

print (y_pred) #predicted values

new_candidates = {'gpa': [2,3.7,3.3,2.3,3],

                  'gmat': [590,740,680,610,710],

                  'work_experience': [3,4,6,1,5]

                  }

df2 = pd.DataFrame(new_candidates,columns= ['gpa','gmat','work_experience'])

df2 = sc.transform(df2)

df2 = pca.transform(df2)

y_pred=logistic_regression.predict(df2)

print (df2)

print (y_pred)

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python – Clustering – Density-Based Spatial Clustering of Applications with Noise (DBScan)

noreply@blogger.com (Eko Wahyudiharto) — Sun, 25 Jul 2021 03:59:00 +0000

Data:

Questionnaire data from mall visitors contains sex, age, salary & shopping score (200 rows).

Mission:

How to predict the probability of shopping score from given age & salary

Library used:

Pandas
Numpy
Seaborn
Matplotlib
Scikit

Code:

import pandas as pd

import numpy as np

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.cluster import DBSCAN

from sklearn.preprocessing import StandardScaler

url = 'https://raw.githubusercontent.com/kokocamp/vlog101/master/vlog101.csv'

vlog131 = pd.read_csv(url)

vlog131.info()

X = vlog131[['Usia','Gaji (juta)']]

y = vlog131['Skor Belanja (1-100)']

sns.scatterplot(x="Usia",y="Gaji (juta)",data=vlog131,color="red",alpha=0.5)

X = np.array(X)

XX = StandardScaler().fit_transform(X)

dbscan = DBSCAN(eps=0.3,min_samples=10)

dbscan.fit(XX)

print(dbscan.labels_)

vlog131["kluster"] = dbscan.labels_

vlog131.head()

fig, ax = plt.subplots()

sct = ax.scatter(X[:,0],X[:,1], c = vlog131.kluster, marker = "o", alpha = 0.5)

plt.title("Hasil Klustering DBSCAN")

plt.xlabel("Usia")

plt.ylabel("Gaji (juta)")

plt.show()

usia = input("Usia (thn): ")

usia = int(usia)

gaji = input("Gaji (juta): ")

gaji = int(gaji)

data = [usia,gaji]

hasil = dbscan.fit_predict([data])

print("Prediksi Kluster: ", hasil)

fig, ax = plt.subplots()

sct = ax.scatter(X[:,0],X[:,1], c = vlog131.kluster, marker = "o", alpha = 0.5)

plt.title("Hasil Klustering DBSCAN")

plt.xlabel("Usia")

plt.ylabel("Gaji (juta)")

plt.scatter(usia,gaji, c = "red", s=100)
plt.show()

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Clustering - T-Distributed Stochastic Neighbor Embedding (T-SNE)

noreply@blogger.com (Eko Wahyudiharto) — Sat, 06 Feb 2021 03:25:00 +0000

Data:

Questionnaire data from mall visitors contains sex, age, salary & shopping score (200 rows).

Mission:

How to predict the probability of shopping score from given age & salary

Library used:

Pandas
Numpy
Seaborn
Matplotlib
Scikit

Code:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.manifold import TSNE

url = 'https://raw.githubusercontent.com/kokocamp/vlog101/master/vlog101.csv'
vlog128 = pd.read_csv(url)
vlog128.info()

X = vlog128[['Usia','Gaji (juta)']]
y = vlog128['Skor Belanja (1-100)']

sns.scatterplot(x="Usia",y="Gaji (juta)",data=vlog128,color="red",alpha=0.5)

n_random = 0
n_kom = 2
perplex = 50
X = np.array(X)
tsne = TSNE(n_components=n_kom, perplexity=perplex).fit_transform(X)
#print(tsne)

n_clusters = 5
kmeans = KMeans(n_clusters)
kmeans.fit(X)
print(kmeans.cluster_centers_)

nc = []
for i in range(n_clusters):
nc.append(i)

print(kmeans.labels_)
vlog128["kluster"] = kmeans.labels_
vlog128.head()

fig, ax = plt.subplots()
sct = ax.scatter(tsne[:,0],tsne[:,1], c = vlog128.kluster, marker = "+", alpha = 0.5)

plt.title("Hasil Klustering T-SNE")
plt.xlabel("Usia")
plt.ylabel("Gaji (juta)")
plt.show()

usia = input("Usia (thn): ")
usia = int(usia)
gaji = input("Gaji (juta): ")
gaji = int(gaji)
data = [usia,gaji]
hasil = kmeans.predict([data])
print("Prediksi Kluster (0-4): ", hasil)
data = np.array([data])

fig, ax = plt.subplots()
sct = ax.scatter(tsne[:,0],tsne[:,1], c = vlog128.kluster, marker = "+", alpha = 0.5)
plt.title("Hasil Klustering Hierarchical Clustering")
plt.xlabel("Usia")
plt.ylabel("Gaji (juta)")

xx = np.append(X,data,axis=0)
tsne2 = TSNE(n_components=n_kom, perplexity=perplex).fit_transform(xx)

plt.scatter(tsne2[:,0],tsne2[:,1], marker = "o", c = "red", alpha = 0.25)
plt.show()

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Clustering - Hierarchical Clustering

noreply@blogger.com (Eko Wahyudiharto) — Thu, 10 Dec 2020 14:06:00 +0000

Data:

Questionnaire data from mall visitors contains sex, age, salary & shopping score (200 rows).

Mission:

How to predict the cluster group from given age & salary

Library used:

Pandas
Numpy
Seaborn
Matplotlib
Scikit

Code:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.cluster import AgglomerativeClustering

url = 'https://raw.githubusercontent.com/kokocamp/vlog101/master/vlog101.csv'
vlog128 = pd.read_csv(url)
vlog128.info()

X = vlog128[['Usia','Gaji (juta)']]
y = vlog128['Skor Belanja (1-100)']

sns.scatterplot(x="Usia",y="Gaji (juta)",data=vlog128,color="red",alpha=0.5)

n_clusters = 5
X = np.array(X)
hc = AgglomerativeClustering(n_clusters, affinity='euclidean', linkage='ward')
hc.fit(X)
#print(X)

nc = []
for i in range(n_clusters):
nc.append(i)

print(hc.labels_)
vlog128["kluster"] = hc.labels_
vlog128.head()

fig, ax = plt.subplots()
sct = ax.scatter(X[:,0],X[:,1], c = vlog128.kluster, marker = "o", alpha = 0.5)
plt.title("Hasil Klustering Hierarchical Clustering")
plt.xlabel("Usia")
plt.ylabel("Gaji (juta)")
plt.show()

usia = input("Usia (thn): ")
usia = int(usia)
gaji = input("Gaji (juta): ")
gaji = int(gaji)
data = [usia,gaji]
data = np.array([data])
xx = np.append(X,data,axis=0)
hasil = hc.fit_predict(xx)
print("Prediksi Kluster (0-4): ", hasil[hasil.size-1])

fig, ax = plt.subplots()
sct = ax.scatter(X[:,0],X[:,1], c = vlog128.kluster, marker = "o", alpha = 0.5)
plt.title("Hasil Klustering Hierarchical Clustering")
plt.xlabel("Usia")
plt.ylabel("Gaji (juta)")
plt.scatter(usia,gaji, c = "red", s=100)
plt.show()

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Clustering - K-Means

noreply@blogger.com (Eko Wahyudiharto) — Wed, 09 Dec 2020 10:02:00 +0000

Data:

Questionnaire data from mall visitors contains sex, age, salary & shopping score (200 rows).

Mission:

How to predict the cluster group from given age & salary

Library used:

Pandas
Numpy
Seaborn
Matplotlib
Scikit

Code:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

url = 'https://raw.githubusercontent.com/kokocamp/vlog101/master/vlog101.csv'
vlog128 = pd.read_csv(url)
vlog128.info()

X = vlog128[['Usia','Gaji (juta)']]
y = vlog128['Skor Belanja (1-100)']

sns.scatterplot(x="Usia",y="Gaji (juta)",data=vlog128,color="red",alpha=0.5)

X = np.array(X)
n_clusters = 5
kmeans = KMeans(n_clusters)
kmeans.fit(X)
print(kmeans.cluster_centers_)

nc = []
for i in range(n_clusters):
nc.append(i)

print(kmeans.labels_)
vlog128["kluster"] = kmeans.labels_
vlog128.head()

fig, ax = plt.subplots()
sct = ax.scatter(X[:,0],X[:,1], c = vlog128.kluster, marker = "o", alpha = 0.5)
centers = kmeans.cluster_centers_
ax.scatter(centers[:,0], centers[:,1], c=nc, s=200, alpha=0.5)
plt.title("Hasil Klustering K-Means")
plt.xlabel("Usia")
plt.ylabel("Gaji (juta)")
plt.show()

usia = input("Usia (thn): ")
usia = int(usia)
gaji = input("Gaji (juta): ")
gaji = int(gaji)
data = [usia,gaji]
hasil = kmeans.predict([data])
print("Prediksi Kluster (0-4): ", hasil)

fig, ax = plt.subplots()
sct = ax.scatter(X[:,0],X[:,1], c = vlog128.kluster, marker = "o", alpha = 0.5)
centers = kmeans.cluster_centers_
ax.scatter(centers[:,0], centers[:,1], c=nc, s=200, alpha=0.5)
plt.title("Hasil Klustering K-Means")
plt.xlabel("Usia")
plt.ylabel("Gaji (juta)")
plt.scatter(usia,gaji, c = "red", s=100)
plt.show()

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Classification - Support Vector Machine (SVM)

noreply@blogger.com (Eko Wahyudiharto) — Tue, 08 Dec 2020 02:18:00 +0000

Data:

Questionnaire data from mall visitors contains sex, age, salary & shopping score (200 rows).

Mission:

How to predict the probability of shopping score from given age & salary

Library used:

Pandas
Matplotlib
Scikit

Code:

import pandas as pd
import matplotlib.pyplot as plt
from sklearn import svm

url = 'https://raw.githubusercontent.com/kokocamp/vlog101/master/vlog101.csv'
vlog126 = pd.read_csv(url)
vlog126.head()

X = vlog126[['Usia','Gaji (juta)']]
y = vlog126['Skor Belanja (1-100)']

svmpred = svm.SVC(kernel='linear')
svmpred.fit(X,y)

usia = input("Usia (thn): ")
usia = int(usia)
gaji = input("Gaji (juta): ")
gaji = int(gaji)
data = [usia,gaji]
print("Prediksi Skor Belanja (1-100): ", svmpred.predict([data]))

plt.scatter(vlog126[['Gaji (juta)']],y, color='green')
plt.scatter(gaji,svmpred.predict([data]), color='red')

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Classification - Naive Bayes (NB)

noreply@blogger.com (Eko Wahyudiharto) — Thu, 03 Dec 2020 02:26:00 +0000

Data:

Questionnaire data from mall visitors contains sex, age, salary & shopping score (200 rows)

Mission:

How to predict the probability of shopping score from given age & salary

Library used:

Pandas
Matplotlib
Scikit

Code:

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.naive_bayes import GaussianNB

url = 'https://raw.githubusercontent.com/kokocamp/vlog101/master/vlog101.csv'
vlog125 = pd.read_csv(url)
vlog125.head()

X = vlog125[['Usia','Gaji (juta)']]
y = vlog125['Skor Belanja (1-100)']

nb = GaussianNB()
nb.fit(X,y)

usia = input("Usia (thn): ")
usia = int(usia)
gaji = input("Gaji (juta): ")
gaji = int(gaji)
data = [usia,gaji]
print("Prediksi Skor Belanja (1-100): ", nb.predict([data]))

plt.scatter(vlog122[['Gaji (juta)']],y, color='green')
plt.scatter(gaji,nb.predict([data]), color='red')

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Classification - Decission Tree (DT)

noreply@blogger.com (Eko Wahyudiharto) — Wed, 02 Dec 2020 11:39:00 +0000

Data:

Questionnaire data from mall visitors contains sex, age, salary & shopping score (200 rows)

Mission:

How to predict the probability of shopping score from given age & salary

Library used:

Pandas
Matplotlib
Scikit

Code:

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeRegressor

url = 'https://raw.githubusercontent.com/kokocamp/vlog101/master/vlog101.csv'
vlog123 = pd.read_csv(url)
vlog123.describe()

X = vlog123[['Usia','Gaji (juta)']]
y = vlog123['Skor Belanja (1-100)']

d3 = DecisionTreeRegressor()
d3.fit(X, y)

usia = input("Usia (thn): ")
usia = int(usia)
gaji = input("Gaji (juta): ")
gaji = int(gaji)
data = [usia,gaji]
print("Prediksi Skor Belanja (1-100): ", d3.predict([data]))

plt.scatter(vlog123[['Gaji (juta)']],y, color='green')
plt.scatter(gaji,d3.predict([data]), color='red')

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Classification - K-Nearest Neighbors (KNN)

noreply@blogger.com (Eko Wahyudiharto) — Tue, 01 Dec 2020 15:06:00 +0000

Data:

Questionnaire data from mall visitors contains sex, age, salary & shopping score (200 rows)

Mission:

How to predict the probability of shopping score from given age & salary

Library used:

Pandas
Matplotlib
Scikit

Code:

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsRegressor

url = 'https://raw.githubusercontent.com/kokocamp/vlog101/master/vlog101.csv'
vlog122 = pd.read_csv(url)
vlog122.describe()

X = vlog122[['Usia','Gaji (juta)']]
y = vlog122['Skor Belanja (1-100)']

knn = KNeighborsRegressor(n_neighbors=3)
knn.fit(X,y)

usia = input("Age (years): ")
usia = int(usia)
gaji = input("Salary (mio): ")
gaji = int(gaji)
data = [usia,gaji]
print("Shopping score prediction (1-100): ", knn.predict([data]))

plt.scatter(vlog122[['Usia']],y, color='green')
plt.scatter(gaji,knn.predict([data]), color='red')

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Regression - Polynomial

noreply@blogger.com (Eko Wahyudiharto) — Sun, 29 Nov 2020 00:32:00 +0000

Data:

Salary list from job position (11 rows)

Mission:

How to predict the probability of salary when a job position (level) added to the list

Library used:

Pandas
Matplotlib
Numpy
Scikit

Code:

import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
import numpy as np
import matplotlib.pyplot as plt
url = 'https://raw.githubusercontent.com/kokocamp/vlog120/main/vlog120.csv'
vlog120 = pd.read_csv(url)
vlog120.describe()
#vlog120.head()

X = vlog120['Level']
y = vlog120['Gaji']
print(y)

derajat = 4
poly_fit = np.poly1d(np.polyfit(X,y, derajat))
xx = np.linspace(0, 13, 100000)
plt.plot(xx, poly_fit(xx), c='r',linestyle='-')
plt.title('Polynomial')
plt.xlabel('Level')
plt.ylabel('Gaji')
plt.grid(True)
plt.scatter(X, y)
plt.show()

print( poly_fit(12) )

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Regression - Logistic

noreply@blogger.com (Eko Wahyudiharto) — Fri, 27 Nov 2020 07:07:00 +0000

Data:

Employees when they sent job applicant (40 rows)

Mission:

How to predict the probability of someone will accepted from given gpa, gmat & work_experience

Library used:

Pandas
Matplotlib
Seaborn
Scikit

Code:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn import metrics
import seaborn as sn
import matplotlib.pyplot as plt

url = 'https://raw.githubusercontent.com/kokocamp/vlog119/main/vlog119.csv'
vlog119 = pd.read_csv(url)
vlog119.describe()

X = vlog119[['gpa', 'gmat','work_experience']]
y = vlog119['admitted']
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.25,random_state=0)

logistic_regression= LogisticRegression()
logistic_regression.fit(X_train,y_train)
y_pred=logistic_regression.predict(X_test)

confusion_matrix = pd.crosstab(y_test, y_pred, rownames=['Actual'], colnames=['Predicted'])
sn.heatmap(confusion_matrix, annot=True)

from sklearn import metrics
print('Accuracy: ',metrics.accuracy_score(y_test, y_pred))
plt.show()

print (X_test) #test dataset
print (y_pred) #predicted values

new_candidates = {'gpa': [2,3.7,3.3,2.3,3],
                  'gmat': [590,740,680,610,710],
                  'work_experience': [3,4,6,1,5]
                  }

df2 = pd.DataFrame(new_candidates,columns= ['gpa','gmat','work_experience'])
y_pred=logistic_regression.predict(df2)

print (df2)
print (y_pred)

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

Python - Regression - Linear

noreply@blogger.com (Eko Wahyudiharto) — Wed, 25 Nov 2020 02:27:00 +0000

Data:

Scikit (diabetes) 442 rows

Mission:

How to predict the probability of someone will get diabetes from given weight data.

Library used:

Matplotlib
Numpy
Scikit

Code:

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn import datasets, linear_model
from sklearn.metrics import mean_squared_error, r2_score
diabetes_X, diabetes_y = datasets.load_diabetes(return_X_y=True)
pd.options.display.float_format = '{:,.4f}'.format
data = pd.DataFrame(data=diabetes_X)
print(data.describe())
diabetes_X = diabetes_X[:, np.newaxis, 2]
data = pd.DataFrame(data=diabetes_X)
print(data.describe())
diabetes_X_train = diabetes_X[:-20]
diabetes_X_test = diabetes_X[-20:]
data = pd.DataFrame(data=diabetes_X_train)
print(data.describe())

data = pd.DataFrame(data=diabetes_X_test)
print(data.describe())
diabetes_y_train = diabetes_y[:-20]
diabetes_y_test = diabetes_y[-20:]
regr = linear_model.LinearRegression()
regr.fit(diabetes_X_train, diabetes_y_train)
diabetes_y_pred = regr.predict(diabetes_X_test)
print('Koef. Determinasi (r2): %.2f' % r2_score(diabetes_y_test, diabetes_y_pred))
plt.scatter(diabetes_X_train, diabetes_y_train, color='green')
plt.scatter(diabetes_X_test, diabetes_y_test, color='black')
plt.plot(diabetes_X_test, diabetes_y_pred, color='blue', linewidth=3)
plt.show()

I wrapped the scenario in a Youtube video below.

Click this link (http://paparadit.blogspot.com/2020/11/the-algorithms-of-machine-learning.html), if you want to check out for other algorithms. Thank you for for visiting this blog & subs my channel.

The Algorithms of Artificial Intelligent

noreply@blogger.com (Eko Wahyudiharto) — Mon, 23 Nov 2020 12:47:00 +0000

I'm new to Python programming and - actually - it just was started in the middle of 2020 for a specific corporate purpose where I'd worked at. So, I've been learned for couple months to explore what is what about Python, and - since there's no best fit guidance about machine learning methodologies - here I summarized about 17 common algorithms I've found.

A. Supervised Learning

Split into 2 methods:

Regression

Classification

B. Unsupervised Learning

Split into 3 methods with 2 models (ML & DL):

Machine Learning

Clustering

Dimension Reduction

Deep Learning

Generative Models

I wrapped this post on a video I published in Youtube:

For those who newbie learner in Python programming, I suggest you to make practice these 7 videos below before start to begin the 17 algorithms above:

And after you completed to study all above videos, I give you 1 video below as a bonus to practice in a real-world business situation:

Customer Segmentation Analysis

Thank you for your reading & subs.Hope you like it...

Importing Various CSV Datasource in Python

noreply@blogger.com (Eko Wahyudiharto) — Thu, 12 Nov 2020 00:07:00 +0000

From previous post (https://paparadit.blogspot.com/2020/11/python-common-libraries.html), we learn how to deal with libraries in Python. On this post, I'm going to show you how to import CSV data using Python. I'll update this post as soon as I discover another way how to do it:

1. CSV from local computer

import pandas as pd
from google.colab import files
uploaded = files.upload()
import io
vlog96 = pd.read_csv(io.BytesIO(uploaded['vlog96.csv']))
vlog96.head()

2. CSV from GitHub

import pandas as pd
url = 'https://raw.githubusercontent.com/kokocamp/vlog96/master/vlog96.csv'
vlog96 = pd.read_csv(url)
vlog96.head()

You can see my video below to make a practice on how to import CSV files from local computer and GitHub.

3. CSV from Google Drive (#1)

The long way:

import pandas as pd

# Code to read csv file into Colaboratory:
!pip install -U -q PyDrive
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from google.colab import auth
from oauth2client.client import GoogleCredentials

# Authenticate and create the PyDrive client.
auth.authenticate_user()
gauth = GoogleAuth()
gauth.credentials = GoogleCredentials.get_application_default()
drive = GoogleDrive(gauth)

link = 'https://drive.google.com/open?id=1-2lhLcwe9QNT8okL69QL_tV-O4BN9um6'
fluff, id = link.split('=')
print (id)
downloaded = drive.CreateFile({'id':id})
downloaded.GetContentFile('vlog98.csv')
vlog98 = pd.read_csv('vlog98.csv')
vlog98.head()

4. CSV from Google Drive (#2)

The simple way:

import pandas as pd

from google.colab import drive
drive.mount('/content/drive')

path = '/content/drive/My Drive/data/vlog96.csv'
vlog96 = pd.read_csv(path)
vlog96.head()

I wrapped both way on a video below:

For GitHub resource, you can use CSV from my account (https://github.com/kokocamp) on or you can make it your own.

Python Common Libraries

noreply@blogger.com (Eko Wahyudiharto) — Wed, 11 Nov 2020 07:01:00 +0000

Months ago, I wrote about my first blog post about Python (https://paparadit.blogspot.com/2020/07/python-for-dummies.html) - as technically I curious about how it works as a machine learning tools. On that link, you can learn (a very) basic Python codes including: (1) How to print out on screen? (2) Learn about variable assignment and data type, (3) Sequences operation, (4) Math operation, (5) Ask for input, (6) Branches, (7) Looping, (8) Array, (9) Quit from looping Function and that's all is a good start for you to learn Python syntax structures. I wrapped it all on 2 video series below.

On current post, I'm going to explain you about Python common libraries I used based on my experiment to create proof-of-concept of several machine learning algorithms. I'll try to update this post as soon as I found new library algorithm used on my code.

1. Matplotlib

A main Python library purposed for graph visualizing.

import matplotlib.pyplot as plt

2. Numpy

A famous Python library for scientific computing.

import numpy as np

I bundled about how to using those Matplotlib and Numpy libraries in a single video below:

3. Pandas

Stand for Python for Data Analysis or some said as PANel DAtaS. It mainly used for data analytical.

import pandas as pd

4. Seaborn

Commonly used for Python statistical graph and strongly integrated with Pandas data structure.

import seaborn as sns

I packed about Pandas and Seaborn example in a video below:

5. Scikit

Mostly contains core statistical algorithms and powerful package to do high-performance linear algebra and array operation with Numpy.

from sklearn.<package> [import <sub_package>]

So, I hope you exactly know what you have to import before playing around with Python. And, remember one thing, "Don't code what you can't debug" :)

Review Samsung Galaxy Tab A6 7.0 Inch 2016 (SM-T285)

noreply@blogger.com (Eko Wahyudiharto) — Sun, 02 Aug 2020 18:37:00 +0000

Does it still relevant gadget in 2020? Yes, at least for me. Some I do & don't like about this tablet:

Yes, I do like:

The compact size (It's only 7 inch instead of 8 inch of latest Samsung Tablet)
Modern bezel design
The battery! (4.000 mAh and it could stand for 2 days)
2Mpx front camera quite good for video meeting

No, I don't like:

1.5GB RAM & 8GB ROM (big issue)
Lollipop is the latest Android OS (No more official update from Samsung since then)
No FHD screen

And here is the complete video review (in Bahasa):

So I recommend this Samsung Galaxy Tab A6 7.0 Inch 2016 (SM-T285) for parents to support their children online class session instead of buying another (overprice) laptop/notebook comparing to this tablet. Have a good day!

Review Casio ProTrek PRG 270

noreply@blogger.com (Eko Wahyudiharto) — Thu, 30 Jul 2020 16:26:00 +0000

So, this is one of my favorite watch and have been used it up for at least 3 years. I bought it when I was in Japan, found it in a local store (BIC Camera outlet) somewhere in a Tokyo downtown. The watch has built-in triple sensors (compass, barometer and altimeter), also it has full-screen automatically illuminator (the light getting on for several seconds when you tilt your hand) and it featured Tough Solar for the power source - no battery inside (CMIIW).

This Casio Pro Trek PRG-270 is so light-weight with 54.6 x 52.4 x 14.4 mm and 67 gram. Along the video also you can find how to wash the watch properly and some tricks to identify the originality of the watch.

Thank you for passing by and please subscribe to this blog.

The Battle of 2020 Smart Assistant

noreply@blogger.com (Eko Wahyudiharto) — Mon, 20 Jul 2020 15:49:00 +0000

Bixby is 1 year old younger than Google Assistant (GA), that's why she loose in this battle today on 2020. The battle contains 20 "hard level" questions consists of 4 What's, 4 Who's, 3 Where's, 3 When's, 4 How's, also 2 of Math & Statistic. Click the video below to watch the fight...

It looks like that Bixby doesn't have her "capsule" on location information instead of GA with Google Maps right on his hands, literally.

And the Artificial Intelligence (AI) fight still continue, this time Cortana vs Google Assistant on Windows 10 right here below, just click to watch the video - Anyway, sorry for the echo on first scene.

In conclusion, congratulation to Google Assistant as the winner. While the round up is Cortana and Bixby at the third. Anyway, thank your for watching & leave your comment below. Don't forget to subscribe to this channel, share & like the video if you love. And see you on my upcoming video. Bye...