Kinerja Tinggi dan Efisiensi Pengembangan

FastAPI, yang dikembangkan oleh Sebastián Ramírez, adalah framework Python tercepat. Ini sebagian besar berkat penggunaan Framework Pydantic untuk validasi data dan Starlette untuk routing. Framework ini memungkinkan pengembang membuat API yang andal dengan kode yang lebih sedikit dan lebih cepat. Karena fitur seperti validasi otomatis dan serialisasi, pengembangan dengan FastAPI dapat lebih cepat hingga 200% hingga 300% dibandingkan dengan framework lain.

Asynchronous Programming

Fitur utama FastAPI yang mendukung programming asynchronous memberikan keuntungan signifikan dalam penulisan kode. Dengan memanfaatkan ‘async’ dan ‘await’, pengembang dapat menciptakan kode non-blocking yang sangat meningkatkan efisiensi operasi I/O. Hasilnya, FastAPI menjadi pilihan yang sangat cocok untuk aplikasi yang menuntut kinerja tinggi, terutama dalam menangani banyak request secara simultan. Efektivitas ini menjadikan FastAPI solusi yang optimal untuk aplikasi web modern yang menghadapi beban trafik yang berat dan memerlukan respons yang cepat.

Dokumentasi dan Standar Terintegrasi

FastAPI menonjol dengan kemampuannya untuk secara otomatis menghasilkan dokumentasi API yang interaktif dan mudah dipahami, menggunakan Swagger UI dan ReDoc. Ini memudahkan baik pengembang maupun pengguna akhir untuk menavigasi dan memahami berbagai endpoint dan struktur API. Selain itu, kepatuhan penuh FastAPI terhadap standar OpenAPI dan JSON Schema memastikan bahwa API yang dibangun bersifat universal dan mudah diintegrasikan dengan berbagai sistem lain. Integrasi ini membuka jalan untuk kolaborasi yang lebih luas dan fleksibilitas dalam pengembangan ekosistem aplikasi yang beragam, meningkatkan interoperabilitas dan efisiensi.

Keamanan dan OAuth2

Selain menyediakan dukungan bawaan untuk keamanan dan autentikasi, framework ini memudahkan integrasi dengan mudah dengan protokol OAuth2 dan JWT. Kemudahan ini memungkinkan pengembang mengimplementasikan sistem autentikasi dan otorisasi yang kuat dalam aplikasi mereka. Oleh karena itu, framework ini memungkinkan aplikasi yang dibangun menggunakannya untuk melindungi data pengguna dan mengontrol akses sambil mempertahankan fleksibilitas dalam pengelolaan hak akses. Ini menjadikan framework ini pilihan yang sempurna untuk pengembangan aplikasi modern yang memerlukan tingkat keamanan dan privasi data yang tinggi.

Dependensi Injection

GPT, fitur canggih FastAPI, yaitu sistem dependensi injection, memudahkan pengembang untuk menggunakan kembali kode, memisahkan kekhawatiran, dan menguji aplikasi dengan lebih mudah. Sistem ini mendukung pembuatan dependensi yang dapat digunakan kembali di berbagai bagian aplikasi, yang meningkatkan modularitas dan kejelasan kode, sehingga meningkatkan efisiensi dalam pengembangan dan pemeliharaan aplikasi. Selain itu, metode ini meningkatkan efisiensi pengembangan dan pemeliharaan aplikasi.

Kesimpulan

FastAPI merevolusi pengembangan web dengan Python dengan kinerja tinggi, dukungan asynchronous, dokumentasi otomatis, dan keamanan yang terintegrasi. Ini adalah pilihan yang bagus untuk pengembangan API modern, baik untuk startup yang ingin meluncurkan produknya dengan cepat atau untuk perusahaan besar yang membutuhkan skalabilitas dan kinerja.

The post FastAPI: Revolusi dalam Pengembangan API Python appeared first on Onestring Lab.

Artikel ini merupakan kelanjutan dari Belajar Data Science – Preprocessing Data Kapal Titanic (Bagian 3). Silahkan baca artikelnya sebelumnya melanjutkan. Data kapal Titanic dapat di akses melalui situs Kaggle.

Import Pustaka

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import cross_val_predict
from sklearn.metrics import confusion_matrix,precision_score
from sklearn.metrics import recall_score,f1_score, roc_auc_score

Modeling

X_train = train_df.drop('Survived', axis=1)
Y_train = train_df['Survived']
X_test = test_df.drop('PassengerId', axis=1)

Random forest

Random Forest adalah supervised learning algorithm. Random Forest membangun beberapa pohon keputusan dan menggabungkannya untuk mendapatkan prediksi yang lebih akurat dan stabil. Satu keuntungan besar dari Random Forest adalah dapat digunakan untuk masalah klasifikasi dan regresi, yang membentuk sebagian besar sistem pembelajaran mesin saat ini. Dengan beberapa pengecualian, pengklasifikasi Random Forest memiliki semua hyperparameter dari pengklasifikasi pohon keputusan dan juga semua hyperparameter dari pengklasifikasi bagging, untuk mengontrol ansambel itu sendiri.

random_forest = RandomForestClassifier(n_estimators=100)
random_forest.fit(X_train, Y_train)

Y_prediction = random_forest.predict(X_test)

random_forest.score(X_train, Y_train)
acc_random_forest = round(random_forest.score(X_train, Y_train)* 100, 2)

results = pd.DataFrame({
    'Model' : ['Random Forest'],
    'Score' : [acc_random_forest]
})
results

hasil dari kode diatas adalah

Random Forest	90.68

K-Fold Cross Validation

Bagaimana kinerja Random Forest saat digunakan validasi silang. K-Fold Cross Validation secara acak membagi data pelatihan menjadi subset K yang disebut folds. Bayangkan data akan dibagi menjadi 10 folds (K = 10). Model Random Forest yang akan dilatih dan dievaluasi 10 kali, menggunakan folds yang berbeda untuk evaluasi setiap saat, sementara itu akan dilatih pada 9 folds lainnya. Oleh karena itu output array dengan 10 skor yang berbeda.

random_forest = RandomForestClassifier(n_estimators=100)
scores = cross_val_score(random_forest, X_train, Y_train, cv=10, scoring = "accuracy")
print("Scores:", scores)
print("Mean:", scores.mean())
print("Standard Deviation:", scores.std())

hasil dari kode program tersebut adalah

Scores: [0.74444444 0.80898876 0.73033708 0.84269663 0.88764045 0.85393258
 0.83146067 0.78651685 0.85393258 0.79775281]
Mean: 0.8137702871410737
Standard Deviation: 0.04756243170100532

Ini terlihat jauh lebih realistis dari sebelumnya. Model memiliki akurasi rata-rata 81% dengan standar deviasi 4,7%. Deviasi standar menunjukkan seberapa tepat estimasi tersebut. Ini berarti hasil pembelajaran keakuratan model dapat berbeda + — 4,7%. Karena akurasinya cukup bagus dan Random Forest adalah model yang mudah digunakan. Untuk meningkatkan kinerjanya lebih jauh lagi sebagai berikut

Hyperparameter Tuning

Untuk meningkatkan kinerjanya dapat dilakukan hyperparameter tunning. Sekarang telah dimiliki model yang tepat, proses mengevaluasi kinerjanya dapat mulai dengan cara yang lebih akurat. Sebelumnya hanyadiggunakan akurasi dan skor oob, yang merupakan bentuk lain dari akurasi.

random_forest = RandomForestClassifier(criterion='gini',
                                       min_samples_leaf=1,
                                       min_samples_split=10,
                                       n_estimators=100,
                                       max_features='auto',
                                       oob_score=True, 
                                       random_state = 1,
                                       n_jobs=-1)

random_forest.fit(X_train, Y_train)
Y_prediction = random_forest.predict(X_test)

random_forest.score(X_train, Y_train)

print("obb score:", round(random_forest.oob_score_,4)*100, "%")

keluaran dari kode program diatas adalah

obb score: 83.73 %

Confusion Matrix

Baris pertama adalah tentang prediksi tidak selamat: 487 penumpang diklasifikasikan dengan benar sebagai tidak selamat (disebut true negatives) dan 62 salah diklasifikasikan sebagai tidak selamat (false positives). Baris kedua adalah tentang prediksi selamat: 98 penumpang salah diklasifikasikan selamat (false negatives) dan 2446 benar diklasifikasikan sebagai selamat (true positives).Confusion matrix memberi banyak informasi tentang seberapa baik model yang dihasilkan, tetapi ada cara untuk mendapatkan lebih banyak lagi, seperti menghitung ketepatan pengklasifikasi.

predictions = cross_val_predict(random_forest, X_train, Y_train, cv=3)
confusion_matrix(Y_train, predictions)

keluaran kode program diatas

array([[487,  62],
       [ 98, 244]])

Precision and Recall

Model telah memprediksi 79% kelangsungan hidup penumpang dengan benar (presisi). Penarikan itu memberi tahu bahwa imeramalkan kelangsungan hidup 71% orang yang benar-benar selamat.

print("Precision:", precision_score(Y_train, predictions))
print("Recall:", recall_score(Y_train, predictions))

keluaran dari kode program diatas

Precision: 0.7973856209150327
Recall: 0.7134502923976608

F-Score

Precision and Recall dapat digabungkan menjadi satu nilai, yang disebut F-Score. F-Score dihitung dengan rata-rata harmonik Precision and Recall. Perhatikan bahwa ini memberikan lebih banyak bobot pada nilai rendah. Akibatnya, pengklasifikasi hanya akan mendapatkan F-Score tinggi, jika Precision and Recall tinggi.

f1_score(Y_train, predictions)

keluaran dari kode program diatas adalah

0.7530864197530864

F-score menunjukkan angka 75%. Skornya tidak terlalu tinggi, karena kami memiliki recall sebesar 71%. Sayangnya, F-score tidak sempurna, karena mendukung pengklasifikasi yang memiliki precision and recall yang serupa. Ini adalah masalah, karena terkadang diinginkan precision dan recall yang tinggi. Masalahnya adalah precision yang meningkat, terkadang menghasilkan perolehan yang menurun pada recall dan sebaliknya (depending on the threshold). Ini disebut tradeoff precision/penarikan.

Kesimpulan

Data kapal Titanic telah dilatih menggunakan model random forest, mengambil dan menerapkan cross validation pada model tersebut. Kemudian dibahas cara kerja random forest dan menyesuaikan kinerjanya dengan mengoptimalkan nilai hyperparameternya. Terakhir, ditunjukkan confusion matrix dan menghitung precision, recall and f-score.

The post Belajar Data Science – Random Forest Untuk Modeling Data Kapal Titanic (Bagian 4) appeared first on Onestring Lab.

Import Pustaka

Melakukan import pustaka yang dibutuhkan yaitu pandas dan numpy.

import pandas as pd
import numpy as np

Mengambil data

Data akan diambil dari github yang disiapkan oleh tim Onestring Lab. Data akan disimpan dalam bentuk Pandas dataframe. Penjelasan mengenai Pandas dataframe dapat dipelajari pada bagian Data Science. Berikut ini kode program untuk mengambil data dari github Onestring Lab. Data yang akan digunakan adalah data train.csv dan test.csv.

train_df = pd.read_csv('https://raw.githubusercontent.com/Onestringlab/osl_datascience/main/data/titanic/train.csv')
train_df.head()

test_df  = pd.read_csv('https://raw.githubusercontent.com/Onestringlab/osl_datascience/main/data/titanic/test.csv')
test_df.head()

Menghapus Beberapa Kolom Data

Pada data kapal Titanic terdapat beberapa kolom yang perlu dihilangkan. Ini dikarenakan data tersebut bersifat unik. Kolom data tersebut adalah Passenger Id, Name, Ticket dan Cabin.

train_df['Ticket'].describe()

Terlihat bahwa dari 891 data terdapat 681 data unik.

count        891
unique       681
top       347082
freq           7
Name: Ticket, dtype: object

Berikut ini adalah perintah drop untuk beberapa kolom tersebut.

train_df = train_df.drop(['Ticket'], axis=1)
test_df  = test_df.drop(['Ticket'], axis=1)
train_df = train_df.drop(['PassengerId'], axis=1)
test_df  = test_df.drop(['PassengerId'], axis=1)
train_df = train_df.drop(['Name'], axis=1)
test_df  = test_df.drop(['Name'], axis=1)
train_df = train_df.drop(['Cabin'], axis=1)
test_df  = test_df.drop(['Cabin'], axis=1)

Mengecek Data Yang Hilang

Berikut ini adalah proses untuk mengetahui data mana saja yang hilang.

row = train_df.shape[0]
total = train_df.isnull().sum().sort_values(ascending=False)
presentase = ((train_df.isnull().sum()/row)*100).sort_values(ascending=False)
presentase = round(presentase,2)
dt_missing = list(zip(total,presentase))
train_df_missing = pd.concat([total,presentase],axis=1,keys=['Total','%'])
train_df_missing

Menggabungan Data Train dan Test

Berikut ini akan menggabungkan data Train dan Test dalam bentuk array.

data = [train_df,test_df]

Mengisi Data Kosong Pada Kolom Age

Untuk data kosong pada kolom Age akan diisi angka random diantara mean – stdeviasi dan mean+ stdeviasi. Berikut ini kode programnya.

train_df['Age'].isnull().sum()

for dataset in data:
  mean = train_df['Age'].mean()
  std = train_df['Age'].std()
  is_null = dataset['Age'].isnull().sum()
  rand_age = np.random.randint(mean-std,mean+std, size= is_null)
  age_slice = dataset['Age'].copy()
  age_slice[np.isnan(age_slice)] = rand_age
  dataset['Age'] = age_slice
  dataset['Age'] = train_df['Age'].astype(int)

train_df['Age'].isnull().sum()

Mengisi Data Kosong Pada Kolom Embarked

Untuk data kosong pada kolom Embarked akan diisi dengan huruf ‘S’ dikarenakan data tersebut paling banyak pada kolom tersebut. Berikut ini kode programnya.

for dataset in data:
  dataset['Embarked'] = dataset['Embarked'].fillna('S')

Mengisi Data Kosong Pada Kolom Fare

Untuk data kosong pada kolom Fare akan diisi dengan angka 0. Berikut ini kode programnya.

for dataset in data:
  dataset['Fare'] = dataset['Fare'].fillna(0)
  dataset['Fare'] = dataset['Fare'].astype(int)

Mengubah Data Pada Kolom Sex dan Embarked

Proses pembelajaran machine learning hanya mengenal angka. Ini mengharuskan melakukan perubahan data string kedalam bentuk bilangan. Kolom Sex yang berisi male dan female akan diubah kedalam bentuk 1 dan 2. Sedangkan kolom Embarked S, C dan Q berubah menjadi 0,1 dan 2. Berikut ini kode programnya.

genders = {"male" : 0, "female" :1}
for dataset in data:
  dataset['Sex'] = dataset['Sex'].map(genders)

ports = {"S":0, "C":1, "Q":2}
for dataset in data:
  dataset['Embarked'] = dataset['Embarked'].map(ports)

Mengompokan Data Kolom Age

Data pada kolom Age sifatnya hampir mendekati unik. Ini kurang baik untuk proses pembelajaran. Hal yang harus dilakukan adalah mengelompokkkanya dalam bentuk range umur. Pada kolom Fare juga akan dilakukan proses yang sama. Berikut ini kode programnya.

for dataset in data:
  dataset['Age'] = dataset["Age"].astype(int)
  dataset.loc[dataset['Age'] <=11, 'Age']=0
  dataset.loc[(dataset['Age'] >11) & (dataset['Age'] <=18), 'Age']=1
  dataset.loc[(dataset['Age'] >18) & (dataset['Age'] <=22), 'Age']=2
  dataset.loc[(dataset['Age'] >22) & (dataset['Age'] <=27), 'Age']=3
  dataset.loc[(dataset['Age'] >27) & (dataset['Age'] <=33), 'Age']=4
  dataset.loc[(dataset['Age'] >33) & (dataset['Age'] <=40), 'Age']=5
  dataset.loc[(dataset['Age'] >40) & (dataset['Age'] <=66), 'Age']=6
  dataset.loc[(dataset['Age'] >66), 'Age']=6

for dataset in data:
  dataset.loc[dataset['Fare'] <=7.91, 'Fare']=0
  dataset.loc[(dataset['Fare'] >=7.91) & (dataset['Fare'] <=14.454), 'Fare']=1
  dataset.loc[(dataset['Fare'] >14.454) & (dataset['Fare'] <=31), 'Fare']=2
  dataset.loc[(dataset['Fare'] >31) & (dataset['Fare'] <=99), 'Fare']=3
  dataset.loc[(dataset['Fare'] >99) & (dataset['Fare'] <=250), 'Fare']=4
  dataset.loc[dataset['Fare'] >250, 'Fare']=5

Membuat Kolom Baru

Untuk proses machine learning dinilai perlu membuat kolom baru yang merupakan hasil kombinasi dari kolom yang sudah ada. Berikut ini kode programnya.

for dataset in data:
    dataset['relatives'] = dataset['SibSp'] + dataset['Parch']
    dataset.loc[dataset['relatives'] > 0, 'not_alone'] = 0
    dataset.loc[dataset['relatives'] == 0, 'not_alone'] = 1
    dataset['not_alone'] = dataset['not_alone'].astype(int)

for dataset in data:
  dataset['Age_Class'] = dataset['Age'] * dataset['Pclass']

for dataset in data:
  dataset['Fare_Per_Person'] = dataset['Fare']/(dataset['relatives']+1)
  dataset['Fare_Per_Person'] = dataset['Fare_Per_Person'].astype(int)

Hasil Preprocessing Data Kapal Titanic

Berikut ini adalah hasil data terakhir setelah dilakukan proses manipulasi.

train_df.head(10)

test_df.head(10)

Kesimpulan Preprocessing Data Kapal Titanic

Proses pengelolaan data merupakan hal terpenting sebelum dilakukan proses pembelajaran. Jika proses ini tidak dilakukan dengan benar dan tepat maka proses pembelajaran tidak ada menghasilkan model yang baik dan bisa digunakan.

The post Belajar Data Science – Preprocessing Data Kapal Titanic (Bagian 3) appeared first on Onestring Lab.

Diagram yang digunakan pada proses visualisasi kali ini adalah Histogram. Dalam bidang statistik, histogram adalah tampilan grafis dari tabel frekuensi yang diwakili oleh grafik batang sebagai bentuk dari pengelompokan data. Setiap tampilan batang menunjukkan proporsi frekuensi di setiap kelompok kategori yang berdekatan pada interval yang tidak tumpang tindih.

Mengambil data

Data akan diambil dari github yang disiapkan oleh tim Onestring Lab. Data akan disimpan dalam bentuk Pandas dataframe. Penjelasan mengenai Pandas dataframe dapat dipelajari pada bagian Data Science. Berikut ini kode program untuk mengambil data dari github Onestring Lab.

import pandas as pd

df = pd.read_csv('https://raw.githubusercontent.com/Onestringlab/osl_datascience/main/data/titanic/train.csv')
df.head()

Histogram Visualisasi Data Kapal Titanic

Bagian ini akan melihat hubungan antara kelompok umur dan jenis kelamin dengan jumlah penumpang yang selamat. Diagram yang akan digunakan pada visualisasi ini adalah Histogram. Berikut ini adalah kode programnya.

import matplotlib.pyplot as plt

data_age_survived =df[['Sex','Age','Survived']].copy()
data_age_survived =df[['Sex','Age','Survived']].copy()
data_male_0 = data_age_survived.loc[(data_age_survived['Sex'] == 'male') & 
                                    (data_age_survived['Survived'] == 0)].copy()
data_male_0 = data_male_0.dropna()

data_male_1 = data_age_survived.loc[(data_age_survived['Sex'] == 'male') & 
                                    (data_age_survived['Survived'] == 1)].copy()
data_male_1 = data_male_1.dropna()

fig = plt.figure(figsize=(12,8))
plt.hist(data_male_0['Age'],40, color ='orange', alpha = 0.7, label = "Not Survived")
plt.hist(data_male_1['Age'],40, color ='blue', alpha = 0.7, label = "Survived")
plt.title('Male')
plt.xlabel('Age')
plt.ylabel('Survived')
plt.legend()
plt.show() 

Keluaran dari kode program ditunjukkan pada gambar berikut ini

data_female_0 = data_age_survived.loc[(data_age_survived['Sex'] == 'female') & 
                                    (data_age_survived['Survived'] == 0)].copy()
data_female_0 = data_female_0.dropna()

data_female_1 = data_age_survived.loc[(data_age_survived['Sex'] == 'female') & 
                                    (data_age_survived['Survived'] == 1)].copy()
data_female_1 = data_female_1.dropna()

fig = plt.figure(figsize=(12,8))
plt.hist(data_female_0['Age'],40, color ='orange', alpha = 0.7, label = "Not Survived")
plt.hist(data_female_1['Age'],40, color ='blue', alpha = 0.7, label = "Survived")
plt.title('Female')
plt.xlabel('Age')
plt.ylabel('Survived')
plt.legend()
plt.show() 

Keluaran dari kode program ditunjukkan pada gambar berikut ini

Kesimpulan

Visualisasi data dapat memberikan pemahaman yang lebih baik daripada data ditampilkan dalam bentuk tabel. Histogram menunjukkan bahwa penumpang wanita dengan rentang usia 20-40 tahun memilki kemungkinan yang tinggi untuk selamat dari kecelakan kapal Titanic dan juga terlihat bahwa pada rentang usia tersebutlah baik penumpang laki-laki atau perempuan yang paling banyak selamat.

The post Belajar Data Science – Visualisasi Data Histogram – Mengeksplorasi Data Kapal Titanic (Bagian 2) appeared first on Onestring Lab.

1. Mengambil data

Data akan diambil dari github yang disiapkan oleh tim Onestring Lab. Data akan disimpan dalam bentuk Pandas dataframe. Penjelasan mengenai Pandas dataframe dapat dipelajari pada bagian Data Science. Berikut ini kode program untuk mengambil data dari github Onestring Lab.

import pandas as pd
df = pd.read_csv('https://raw.githubusercontent.com/Onestringlab/osl_datascience/main/data/titanic/train.csv')
df.head()

2. Mengetahui jenis data dan jumlah data

Langkah selanjutnya adalah mengetahui jenis data yang pada setiap variabel. Selain itu, juga untuk mengetahui berapa jumlah kelengkapan data pada masing-masing variabel. Tipe data variabel pada data kapal Titanic cukup beragam yaitu int64, object, dan float64. Untuk jumlah data kosong, variabel Age dan Cabin memiliki data kosong. Variabel Age memiliki 177 data kosong, sedangkan variabel Cabin memiliki 687 data kosong.

df.info()

4. Mengetahui statistik deskriptif

Bagian ini akan diperlihatan statistif deskriptif dari data kapal Titanic. Data menunjukan bahwa jumlah data sebanyak 891 data dan presentase rata-rata penumpang selamat pada tragedi tenggelamnya kapa tersebut sebesar 38.38%. Selain itu, pada variabel Age juga dapat diketahui pada usia penumpang kapal Titani antar 0.42 – 80 tahun.

df.describe()

5. Mengetahui jumlah data yang kosong

Bagian ini akan mengeksplorasi lebih jauh mengenai variabel yang memiliki data yang kosong. Tabel menunjukkan bahwa terdapat 2 variabel yang memiliki data kosong, yaitu Cabin dan Age. Variabel Cabin memiliki presetanse data kosong sebesar 77.10%, sedangkan Age sebesar 19.92%.

row = df.shape[0]
total = df.isnull().sum().sort_values(ascending=False)
presentase = ((df.isnull().sum()/row)*100).sort_values(ascending=False)
presentase = round(presentase,2)
dt_missing = list(zip(total,presentase))
df_missing = pd.concat([total,presentase],axis=1,keys=['Total','%'])
df_missing

Kesimpulan Mengeksplorasi Data Kapal Titanic

Setelah dilakukan eksplorasi tahap awal pada data Kapal Titanic maka dapat disimpulkan bahwa data ini memiliki 891 baris data terdiri dari 11 variabel dengan tipe data int64, float64 dan object dan terdapat 2 variabel yang memiliki data kosong yaitu Cabin dan Age. Cabin memiliki presentase data kosong yang besar yaitu mencapai 77.10%, sehingga layak untuk tidak digunakan, sedangkan variabel Age masih di layak untuk digunakan untuk proses selanjutnya.

The post Belajar Data Science – Mengeksplorasi Data Kapal Titanic (Bagian 1) appeared first on Onestring Lab.

Kisaran nilai yang mungkin untuk koefisien korelasi adalah -1,0 hingga 1,0. Artinya, nilainya tidak boleh melebihi 1,0 dan kurang dari -1,0. Angka -1,0 menunjukkan nilai korelasi negatif sempurna dan 1,0 berarti angka korelasi positif yang sempurna. Secara visual seperti yang ditunjukan pada Gambar 1.

Interprestasi Korelasi

Ada 3 penafsiran hasil analisis korelasi :

1. Melihat arah hubungan antar dua variabel
2. Melihat kekuatan hubungan antar dua variabel
3. Melihat signifikansi hubungan antar dua variabel

Klasifikasi Koefisien Korelasi

Adapun klasifikasi Koefisien Korelasi menurut Jonathan Sarwono adalah:

Contoh Mencari Koefisien Korelasi

Misalkan terdapat 2 data yaitu x dan y, nilai dari kedua saya tersebut adalah

Hitunglah nilai koefisien korelasinya.

Kode Python

In [1]:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

In [2]:

#data
x = [18,16,20,22,26,12,14,20]
y = [12,10,8,20,24,10,16,18]

In [3]:

#membuat dataframe
df = pd.DataFrame(list(zip(x, y)),
               columns =['x', 'y'])
df.head()

Out[3]:

	x	y
0	18	12
1	16	10
2	20	8
3	22	20
4	26	24

In [4]:

df.describe()

Out[4]:

	x	y
count	8.000000	8.000000
mean	18.500000	14.750000
std	4.503967	5.650537
min	12.000000	8.000000
25%	15.500000	10.000000
50%	19.000000	14.000000
75%	20.500000	18.500000
max	26.000000	24.000000

In [5]:

#rata-rata variabel x
df['x'].mean()

Out[5]:

18.5

In [6]:

#rata-rata variabel y
df['y'].mean()

Out[6]:

14.75

Correlation (r)¶

$$ r= \frac{\sum{(x-\overline{x})(y-\overline{y})}}{\sqrt{\sum{(x-\overline{x}})^2 \sum{(y-\overline{y}})^2}} $$

Menghitung korelasi menggunakan numpy¶

In [7]:

np.corrcoef(df['x'], df['y'])

Out[7]:

array([[1.        , 0.67920744],
       [0.67920744, 1.        ]])

Menghitung korelasi secara manual¶

In [8]:

x_mean = df['x']-df['x'].mean()
print(x_mean)
y_mean = df['y']-df['y'].mean()
print(y_mean )

0   -0.5
1   -2.5
2    1.5
3    3.5
4    7.5
5   -6.5
6   -4.5
7    1.5
Name: x, dtype: float64
0   -2.75
1   -4.75
2   -6.75
3    5.25
4    9.25
5   -4.75
6    1.25
7    3.25
Name: y, dtype: float64

In [9]:

sum_ = np.sum(x_mean * y_mean)
sum_

Out[9]:

121.0

In [10]:

sqrt_ = np.sqrt(np.sum(x_mean**2)* np.sum(y_mean**2))
sqrt_

Out[10]:

178.1488141975691

In [11]:

correlation = sum_/sqrt_
print(correlation)

0.6792074398306666

In [12]:

plt.title('Korelasi variabel x dan y')
plt.scatter(df['x'], df['y'])
plt.xlabel('x')
plt.ylabel('y')
plt.show()

Hubungan antara variabel x dan y adalah berkorelasi kuat.

Kesimpulan

Jika mengetahui adanya hubungan 2 variabel, maka akan diketahui 1 variabel bisa dilakukan penaksiran terhadap 1 variabel lain, melalui bantuan garis regresi. Korelasi memungkinkan peneliti untuk mempelajari variabel alami yang mungkin tidak praktis untuk diuji secara eksperimental.

Untuk artikel terkait statistik dapat dilihat di sini.

The post Belajar Statistik – Apa itu koefisien korelasi? appeared first on Onestring Lab.

Pada artikel ini akan ditulis sebuah program untuk membuat sebuah bunga warna-warni. Bila belum mengetahui konsep dasar dari bahasa pemrograman Python silahkan kunjungin artikel Konsep Dasar Python.

Bunga Warna-warni dengan library Turtle

import turtle

s = turtle.Screen()
t = turtle.Turtle()

s.bgcolor('#262626')
t.pencolor('#540d6e')
t.speed(100)
col = ('#ee4266', '#ffd23f', '#3bceac', '#0ead69')

for n in range(5):
    for x in range(8):
        t.speed(x+10)
        for i in range(2):
            t.pensize(2)
            t.circle(80+n*20,90)
            t.lt(90)
        t.lt(45)
    t.pencolor(col[n%4])
s.exitonclick()

Hasil Keluaran Program

The post Belajar Python – Library Turtle Untuk Membuat Bunga Warna-warni appeared first on Onestring Lab.

Statistik Deskriptif

Statistik deskriptif adalah cara untuk mengatur, melihat, dan mendeskripsikan kumpulan data menggunakan tabel, bagan, dan banyak parameter numerik lainnya. Beberapa istilah statistik yang termasuk dalam kelompok Deskripsi adalah:

• Mean – Nilai rata-rata dari data yang bertipe numerik/angka.
• Median – Nilai tengah yang membagi data terurut menjadi 2 bagian sama besar.
• Mode – Nilai yang paling sering muncul dari data.
• Standard Deviation – Rata-rata kuadrat dari selisih/jarak setiap observasi dengan nilai mean. 
• Correlation – Nilai yang menggambarkan keeratan hubungan antara dua variabel numerik. Belum tentu menggambarkan hubungan sebab akibat.
• Variance – Nilai yang menggambarkan seberapa bervariasi/beragamnya suatu data bertipe numerik/angka.

Seorang Data Scientists sangat memerlukan statistik deskriptif untuk mengenali pola dari datanya . Namun, jenis statistik ini hanya dapat digunakan dengan sampel data yang diselidiki dan tidak dapat digunakan untuk menarik generalisasi atau inferensi tentang populasi atau kelompok lain. Contohnya adalah kumpulan data untuk kota-kota yang menggunakan handphone atau memiliki sepeda motor . Misalnya, menurut BPS (Badan Pusat Statistik), jumlah sepeda motor di Indonesia mencapai 161,44 juta pada tahun 2018. Jumlah handphone sudah mencapai 120,1 juta.

Statistik inferensial

Statistik inferensial adalah teknik yang dapat digunakan untuk menganalisis sekelompok kecil sampel dari data induk atau populasi untuk membuat prediksi dan kesimpulan tentang kelompok data induk atau populasi. Statistik inferensial adalah ringkasan dari semua metode untuk menganalisis beberapa data dan mengarah pada prediksi atau kesimpulan tentang seluruh data induk (populasi). Generalisasi yang terkait dengan inferensi statistik tidak pasti karena didasarkan pada informasi parsial yang diperoleh dari bagian-bagian data. Jadi apa yang didapatkan hanyalah prediksi.

Berdasarkan ruang lingkup bahasannya, statistika inferensial mencakup:

• Probabilitas atau teori kemungkinan
• Dristribusi teoritis
• Analisis kovarians
• Sampling dan sampling distribusi
• Pendugaan populasi atau teori populasi
• Analisis varians
• Uji Hipotesis
• Analisis korelasi dan uji signifikasi
• Analisis regresi untuk peramalan

Statistik deskriptif dan inferensial pada Python

Statistik Deskriptif
Statistik deskriptif berkaitan dengan penyajian dan pengumpulan data

import library yang digunakan

In [ ]:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

In [ ]:

# membuat data berupa data umur antara 20-35 sebanyak 10 buah
df1 = pd.DataFrame(dict(id=range(10), umur= np.random.randint(20,35, size=10)))
df1

Out[ ]:

	id	umur
0	0	21
1	1	25
2	2	22
3	3	32
4	4	30
5	5	27
6	6	31
7	7	33
8	8	27
9	9	20

In [ ]:

# mencari rata-rata
df1.umur.mean()

Out[ ]:

26.8

In [ ]:

# mencari nilai tengah
df1.umur.median()

Out[ ]:

27.0

In [ ]:

# mencari data yang paling banyak muncul
df1.umur.mode()

Out[ ]:

0    27
dtype: int64

In [ ]:

# mencari variance
df1.umur.var()

Out[ ]:

22.177777777777777

In [ ]:

# mencari standar deviasi
df1.umur.std()

Out[ ]:

4.7093288033198295

In [ ]:

# mencari rentang data
df1.umur.max() - df1.umur.min()

Out[ ]:

13

In [ ]:

# melihat sebaran menggunakan boxplot
df1.boxplot(column='umur', return_type='axes')

Out[ ]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f352440bf90>

Skewness dan Kurtosis

In [ ]:

# mencari nilai skewness
df1['umur'].skew()

Out[ ]:

-0.18638654204889551

In [ ]:

# mencari nilai kurtosis
df1['umur'].kurt()

Out[ ]:

-1.4834127172180032

Statistik Inferensial
Analisis statistik inferensial menyimpulkan sifat-sifat suatu populasi, misalnya dengan menguji hipotesis dan menurunkan perkiraan

import library yang digunakan

In [1]:

import numpy as np
import pandas as pd
import scipy.stats as stats
import matplotlib.pyplot as plt

In [2]:

# membuat data sebanyak 1000 buah
populasi = np.random.randint(10, 20, 1000)

np.random.seed(10)

# membuat list untuk menyimpan perkiraan setiap pengambilan sampel data
perkiraan = []

# membuat 
for x in range(200):
  # mengambil sampel 100 data dari populasi
  sampel = np.random.choice(a=populasi, size=100)

  # merata-ratakan data sampel dan disimpan pada list
  perkiraan.append(sampel.mean())

In [3]:

# mencari rata-rata dari populasi]
populasi.mean()

Out[3]:

14.567

In [4]:

pd.DataFrame(perkiraan).plot(kind='density')

Out[4]:

<matplotlib.axes._subplots.AxesSubplot at 0x7f04b331e3a0>

Titik Perkiraan
Interval Kepercayaan

Error Margin $$marginOfError = (criticalValue)* \frac{(standarDeviation)}{\sqrt(sampleSize)}$$

In [5]:

z_critical = stats.norm.ppf(q = 0.975)

In [6]:

margin_of_error = z_critical * (np.std(perkiraan)/np.sqrt(200))
margin_of_error

Out[6]:

0.039042256270319556

In [7]:

# lower : sampel_mean - margin_of_error
np.mean(perkiraan) - margin_of_error

Out[7]:

14.53175774372968

In [8]:

# upper : sampel_mean + margin_of_error
np.mean(perkiraan) + margin_of_error

Out[8]:

14.609842256270317

In [9]:

t_critical = stats.t.ppf(q = 0.975, df=24)

In [10]:

margin_of_error = t_critical * (np.std(perkiraan)/np.sqrt(200))
margin_of_error

Out[10]:

0.04111262104539879

In [11]:

# lower : sampel_mean - margin_of_error
np.mean(perkiraan) - margin_of_error

Out[11]:

14.5296873789546

In [12]:

# upper : sampel_mean + margin_of_error
np.mean(perkiraan) + margin_of_error

Out[12]:

14.611912621045397

Kesimpulan mengenai statistik deskriptif dan inferensial

Statistik deskriptif hanya sebatas menampilkan data dalam bentuk tabel, bagan, grafik, dan besaran lainnya. Selain statistik deskriptif, statistik inferensial sekarang dapat digunakan untuk menarik kesimpulan tentang populasi dari sampel. Sehingga dapat disimpulkan inferensi statistik melalui tahapan pengujian hipotesis dan pengujian statistik. Artikel lain terkait statistik dapat dilihat di sini.

The post Belajar Statistik – Statistik Deskriptif dan Inferensial Pada Python appeared first on Onestring Lab.

Apa itu Ukuran Penyebaran?

Ukuran penyebaran memberikan variabilitas dalam data dan seberapa baik data didistribusikan. Untuk mendapatkan gambaran keseluruhan dari data, kita akan menggunakan tendensi sentral dan ukuran deskripsi. Hal ini terutama digunakan dalam polling pemilihan, atau untuk menilai nilai ujian atau bahkan persentase kenaikan gaji.

Ukuran penyebaran terbagi 4 kategori

1. Range
2. Quartile
3. Variance
4. Standar Deviasi

Jupyter Notebook

import numpy as np

# generate 30 data bilangan real
data = np.random.randn(30)
data

array([-0.20181808,  0.56644081, -0.5385213 ,  0.95774588,  0.97635735,
       -1.0941052 ,  0.93006759,  0.4492942 ,  0.19985695,  0.66997106,
        0.14827642,  1.2728451 , -0.11812149,  0.60403548, -0.40400818,
        0.62219441,  0.46435442,  0.27383479, -0.89920297, -0.05828149,
        0.74119153, -0.55061788, -0.68031783,  1.54683908, -1.66209298,
        1.20524697,  0.32575178, -0.07868015,  0.53524161, -0.01932291])

# mengurutkan data
data = np.sort(data)
data

array([-1.66209298, -1.0941052 , -0.89920297, -0.68031783, -0.55061788,
       -0.5385213 , -0.40400818, -0.20181808, -0.11812149, -0.07868015,
       -0.05828149, -0.01932291,  0.14827642,  0.19985695,  0.27383479,
        0.32575178,  0.4492942 ,  0.46435442,  0.53524161,  0.56644081,
        0.60403548,  0.62219441,  0.66997106,  0.74119153,  0.93006759,
        0.95774588,  0.97635735,  1.20524697,  1.2728451 ,  1.54683908])

# menghitung range
np.max(data) - np.min(data)

3.2089320572772344

# Quartile Pertama
Q1 = np.percentile(data,25)
Q1

-0.18089393017739763

# Quartile Kedua
Q2 = np.percentile(data,50)
Q2

0.2997932878575289

# Quartile Ketiga
Q3 = np.percentile(data,75)
Q3

0.6580268993082843

IQR = Q3 - Q1
IQR

0.8389208294856819

# generate 100 data bilangan real
populasi = np.random.randn(100)

# mengurutkan data
populasi = np.sort(populasi)

populasi

array([-2.53211626e+00, -1.98230935e+00, -1.56840010e+00, -1.50407864e+00,
       -1.43215884e+00, -1.36079405e+00, -1.31673459e+00, -1.26141567e+00,
       -1.06062988e+00, -1.06062771e+00, -9.78396710e-01, -9.77292420e-01,
       -9.64091140e-01, -9.48780367e-01, -9.24499652e-01, -9.04653064e-01,
       -8.56245634e-01, -7.67055257e-01, -7.30042060e-01, -7.01571723e-01,
       -6.95768924e-01, -6.94302445e-01, -6.94119909e-01, -6.45289676e-01,
       -6.22733420e-01, -6.01237917e-01, -5.95411061e-01, -5.87801735e-01,
       -5.86108748e-01, -5.73332169e-01, -5.40135774e-01, -4.63402257e-01,
       -4.46188339e-01, -4.21859375e-01, -3.57440395e-01, -3.32591025e-01,
       -3.30816966e-01, -3.11657057e-01, -2.83051890e-01, -2.79316128e-01,
       -2.69953269e-01, -2.38457920e-01, -2.09225580e-01, -1.79321574e-01,
       -1.65357898e-01, -1.65034083e-01, -1.61820912e-01, -1.55502134e-01,
       -7.32946941e-02, -4.87252346e-02, -4.65713333e-02, -2.78876738e-02,
       -5.62504973e-04,  1.55312885e-03,  1.61204312e-03,  1.12644357e-02,
        5.85513500e-02,  6.71316417e-02,  9.41455675e-02,  9.57520488e-02,
        1.28188529e-01,  1.57180103e-01,  2.25363633e-01,  3.30052735e-01,
        3.78691235e-01,  3.80828982e-01,  4.27167209e-01,  4.34420849e-01,
        4.46889945e-01,  4.71867190e-01,  5.00382295e-01,  5.01100163e-01,
        5.68993168e-01,  5.92910356e-01,  5.99786642e-01,  6.05940466e-01,
        6.23246039e-01,  6.25202110e-01,  6.85139416e-01,  6.92884674e-01,
        7.56749547e-01,  8.42005769e-01,  8.74988284e-01,  9.05711220e-01,
        9.15043533e-01,  9.33772173e-01,  9.71122009e-01,  9.92562992e-01,
        1.02604635e+00,  1.04729636e+00,  1.06295994e+00,  1.11294042e+00,
        1.20282996e+00,  1.21598137e+00,  1.32093338e+00,  1.35358198e+00,
        1.37846837e+00,  1.42845490e+00,  1.58786941e+00,  1.74833911e+00])

# generate 100 data bilangan real
sampel = np.random.choice(populasi, 20)

# mengurutkan data
sampel = np.sort(sampel)

sampel

array([-1.31673459e+00, -9.78396710e-01, -9.64091140e-01, -7.67055257e-01,
       -5.95411061e-01, -4.46188339e-01, -4.46188339e-01, -3.32591025e-01,
       -3.32591025e-01, -2.38457920e-01, -2.09225580e-01, -1.55502134e-01,
       -5.62504973e-04,  3.30052735e-01,  4.46889945e-01,  5.01100163e-01,
        6.05940466e-01,  7.56749547e-01,  9.92562992e-01,  1.06295994e+00])

np.var(populasi)

0.6997660157012142

np.var(sampel)

0.43522759137818684

np.std(populasi)

0.836520182482894

np.std(sampel)

0.6597178119303638

Kesimpulan

Telah dipelajari mengenai cara mengukur sebaran data. Untuk artikel lain terkait dengan statistik silahkan lihat kumpulan artikelnya disini.

The post Belajar Statistik – Apa itu Ukuran Penyebaran? appeared first on Onestring Lab.

Import pustaka dan deklarasi variabel

import turtle

WARNA_BADAN = 'red'
WARNA_KACAMATA = 'skyblue'

s = turtle.getscreen()
t = turtle.Turtle()

Badan

Berikut ini merupakan fungsi untuk membuat badan dari karakter.

# fungsi untuk menggambar badan
def badan():  
    t.pensize(20)

    t.fillcolor(WARNA_BADAN)
    t.begin_fill()

    t.right(90)
    t.forward(50)
    t.right(180)
    t.circle(40, -180)
    t.right(180)
    t.forward(200)

    t.right(180)
    t.circle(100, -180)

    t.backward(20)
    t.left(15)
    t.circle(500, -20)
    t.backward(20)

    t.circle(40, -180)

    t.left(7)
    t.backward(50)

    t.up()
    t.left(90)
    t.forward(10)
    t.right(90)
    t.down()
    t.right(240)
    t.circle(50, -70)

    t.end_fill()

Kacamata

Berikut ini merupakan fungsi untuk membuat kacamata dari karakter.

# fungsi untuk menggambar kacamata
def kacamata():
    t.up()
    t.right(230)
    t.forward(100)
    t.left(90)
    t.forward(20)
    t.right(90)

    t.down()
    t.fillcolor(WARNA_KACAMATA)
    t.begin_fill()

    t.right(150)
    t.circle(90, -55)

    t.right(180)
    t.forward(1)
    t.right(180)
    t.circle(10, -65)
    t.right(180)
    t.forward(110)
    t.right(180)

    t.circle(50, -190)
    t.right(170)
    t.forward(80)

    t.right(180)
    t.circle(45, -30)

    t.end_fill()

Tas

Berikut ini merupakan fungsi untuk membuat tas dari karakter.

# fungsi untuk menggambar tas
def tas():
    t.up()
    t.right(60)
    t.forward(100)
    t.right(90)
    t.forward(75)

    t.fillcolor(WARNA_BADAN)
    t.begin_fill()

    t.down()
    t.forward(30)
    t.right(255)

    t.circle(300, -30)
    t.right(260)
    t.forward(30)

    t.end_fill()

Memanggil fungsi yang telah di buat

badan()
kacamata()
tas()
t.screen.exitonclick()

Keluaran

Keluaran dari program diatas secara keseluruhan tampak seperti pada gambar di bawah ini. Buatlah karakter dengan warna yang lain.

Untuk artikel lain terkait dengan pemrograman Python silahkan lihat kumpulan artikelnya disini.

The post Belajar Python – Membuat Karakter Among Us appeared first on Onestring Lab.

Jupyter Notebook

import numpy as np
import matplotlib.pyplot as plt

# angka dari 7 - 10 sebanyak 20 buah
data = np.random.randint(7,10,20)
data

array([8, 8, 9, 8, 9, 7, 8, 7, 7, 9, 9, 7, 9, 7, 8, 7, 8, 9, 7, 8])

# mean atau rata-rata
np.mean(data)

7.95

data = np.sort(data)
print(data)
np.median(data)

[7 7 7 7 7 7 7 8 8 8 8 8 8 8 9 9 9 9 9 9]

8.0

# Nilai mode dicari dengan fungsi mode
import statistics
mode = statistics.mode(data)
mode

7

# populasi data angka dari 1 sampai 9 sebanyak 100 buah
populasi = np.random.randint(1,10,100)
populasi

array([3, 1, 8, 6, 6, 1, 5, 7, 7, 7, 6, 8, 2, 7, 8, 1, 4, 9, 5, 7, 8, 3,
       7, 6, 4, 7, 1, 3, 2, 1, 9, 5, 2, 2, 6, 8, 6, 4, 2, 4, 5, 1, 5, 6,
       2, 3, 7, 6, 8, 5, 6, 2, 2, 2, 9, 7, 4, 2, 9, 1, 5, 9, 2, 7, 9, 9,
       7, 6, 9, 2, 2, 3, 7, 9, 3, 8, 7, 3, 1, 1, 5, 3, 2, 7, 4, 1, 3, 3,
       6, 3, 6, 7, 9, 5, 1, 3, 5, 9, 4, 6])

print("Mean :",np.mean(populasi))
print("Median :",np.median(populasi))
print("Mode :",statistics.mode(populasi))

Mean : 4.91
Median : 5.0
Mode : 7

sampel = np.random.choice(populasi, 20)
sampel

array([8, 1, 2, 2, 2, 9, 1, 1, 1, 7, 7, 2, 5, 9, 9, 1, 8, 3, 7, 9])

print("Mean :",np.mean(sampel))
print("Median :",np.median(sampel))
print("Mode :",statistics.mode(sampel))

Mean : 4.7
Median : 4.0
Mode : 1

sampel_1 = np.random.choice(populasi, 15)
sampel_2 = np.random.choice(populasi, 15)
sampel_3 = np.random.choice(populasi, 15)
sampel_4 = np.random.choice(populasi, 15)

# memuat sampel-sampel ke dalam list
data_sampel = [sampel_1, sampel_2, sampel_3, sampel_4]
mean_sampel = []

for x in data_sampel:
  mean_sampel.append(np.mean(x))

mean_sampel

[5.2, 4.4, 3.6666666666666665, 4.733333333333333]

print("Mean dari sample", np.mean(mean_sampel))

Mean dari sample 4.5

print("Mean dari populasi", np.mean(populasi))

Mean dari populasi 4.91

Kesimpulan

Mean adalah rata-rata, median adalah nilai tengah dan modus adalah nilai yang paling sering muncul dalam suatu data. Untuk artikel lain terkait dengan statistik silahkan lihat kumpulan artikelnya disini.

The post Belajar Statistik – Mean, Median, Mode dan Populasi appeared first on Onestring Lab.

Saya tidak akan membuang waktu Anda. Jadi, dalam “pertarungan” ini, saya akan memberikan kesimpulan bahwa “Tidak Ada Pemenang“. Apa yang harus selalu dipikirkan adalah “Bagaimana data dapat membantu memecahkan masalah atau menjawab pertanyaan?” Inilah yang benar-benar penting. Bahasa pemrograman merupakan hanya sebuah alat. Sebagai data science, analis data, ahli statistik, atau siapa pun yang memiliki masalah dan akses ke data maka harus fokus pada pemecahan masalah menggunakan data yang ada. Hal itu yang membuat “Anda” menjadi pemenangnya.

Tools are just supplements to help you solve your problems

Oke, karena Anda masih di sini, dan sekarang saya telah menyelesaikan tujuan pertama saya dalam artikel ini (untuk menekankan bahwa bahasa pemrograman hanyalah pelengkap untuk membantu dalam pemecahan masalah), izinkan saya melanjutkan ke tujuan kedua saya. Bahasa pemrograman apa yang harus digunakan untuk membantu agar tercapai tujuan yang diinginkan? Dan untuk menjawab ini, Anda harus terlebih dahulu memahami apa yang dilakukan setiap bahasa pemrograman ini. Biarkan saya membuat perbandingan antara Python dan R di artikel ini.

Tujuan

Pertama-tama mari kita bedakan keduanya berdasarkan tujuan. Berdasarkan Ringkasan Eksekutif Python di python.org, “Python adalah bahasa pemrograman tingkat tinggi yang diinterpretasikan, berorientasi objek,” . Di sisi lain, “R adalah bahasa dan lingkungan untuk komputasi statistik dan grafik” menurut r-project.org.

Secara sederhana, Python dibuat sebagai bahasa pemrograman untuk membangun situs web dan aplikasi, sedangkan R adalah alat statistik untuk analisis data, pemodelan, dan visualisasi. R menyediakan fungsi dasar untuk bekerja dengan data (tidak seperti Python, yang sering menggunakan numpy dan panda), sedangkan Python lebih efisien untuk analisis yang lebih rumit (tidak seperti R, yang sedikit lebih lambat untuk beberapa model pembelajaran mesin) dan dapat digunakan untuk model pembelajaran mesin lainnya. tujuan.

Sintaks dan struktur pengkodean.

Python dan R, tentu saja, memiliki sintaks sendiri. Tetapi pertimbangkan betapa berbedanya mereka dalam hal struktur.

Python. Sebagai bahasa pemrograman berorientasi objek, Anda akan melihat bahwa mengetik tanda “.”” setelah variabel atau fungsi memberi Anda sub-fungsi atau metode lain yang melakukan tugas. Kita akan menemukan diri bekerja dengan tanda “.” ini untuk memanggil metode atau properti.

R. Struktur R berbeda. R dianggap sebagai bahasa pemrograman fungsional yang berarti sebagian besar akan bekerja dengan kata kunci yang ditambahkan dengan tanda kurung dan melewati beberapa parameter. Jika Anda telah menggunakan rumus/fungsi bersarang Excel, itu agak mirip di R.

Saya telah melihat kesamaan dalam beberapa kasus, tetapi dari segi sintaks, Python lebih mudah dipelajari daripada R. Ketika datang ke fungsi untuk analisis data, R memiliki banyak perintah bawaan, sementara Python mungkin memerlukan fungsi dari modul matematika dan numpy.

You can still do what you need regardless of what you choose.

Jadi, mana yang harus Anda pilih?

Apa pun yang dipilih, Kita masih dapat mengikuti proses standar untuk mengevaluasi kumpulan data. Bahkan, lebih baik jika menguasai kedua bahasa pemrograman tersebut karena industri yang berbeda menggunakan bahasa pemrograman yang berbeda. Saat berpindah dari satu perusahaan ke perusahaan lain, Anda mungkin perlu mengonversi dari R ke Python atau sebaliknya, atau ke teknologi lain (seperti Excel, SQL, dan Julia). Namun, ketika memutuskan apa yang akan digunakan, ingatlah tujuan sebenarnya.

1. Jika fokus pada uji statistik dan pemodelan maka bahasa pemrograman R mungkin lebih mudah digunakan. Hal ini sudah jelas karena R ini adalah perangkat lunak statistik.
2. Jika bekerja dengan kumpulan data yang sangat besar maka Python akan menjadi pilihan terbaik untuk ini karena akan lebih efisien untuk bekerja dengan data besar di Python daripada di R. Meskipun R juga cocok untuk data besar.
3. Jika akan mengintegrasikan proyek ini dengan di aplikasi lain maka Python akan menjadi yang paling cocok untuk tujuan ini. R juga memiliki kerangka kerja pengembangan web yang disebut shiny yang memungkinkan dapat membuat aplikasi web.
4. Jika bekerja dengan bagan dan grafik maka R lebih baik daripada Python. Terlepas dari fungsi dasarnya untuk visualisasi data, R memiliki paket yang disebut ggplot2 yang memiliki beberapa fungsi untuk membuat bagan dan grafik yang indah hanya dalam beberapa baris kode. Python memiliki matplotlib untuk menyesuaikan grafik, dan seaborn untuk visualisasi yang cepat, mudah, dan cantik.

Although data science is tied with the tools, solving problems and answering questions is still at the center of this discipline.

Kesimpulan

Data science membantu menjawab pertanyaan dan/atau memecahkan masalah dengan menggunakan data. Meskipun bahasa pemrograman, seperti Python dan R, biasanya terkait dengan kata ini. Hal yang harus tetap ingat bahwa tujuan utamanya adalah untuk memecahkan masalah dan menjawab pertanyaan melalui data.

Fokus pada satu bahasa pemrograman sebelum pergi ke yang lain menjadi sebuah keharusan. Dasar-dasar fungsi dan perintah dasar harus diprioritaskan sebelum mempelajari modul dan library.

The post Pertarungan Python dan R Telah Berakhir appeared first on Onestring Lab.