dlopss 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- dlopss/__init__.py +45 -0
- dlopss/data/__init__.py +1 -0
- dlopss/data/a/__init__.py +1 -0
- dlopss/data/a/p1 +30 -0
- dlopss/data/a/p2 +81 -0
- dlopss/data/a/p3 +73 -0
- dlopss/data/a/p4 +48 -0
- dlopss/data/a/p5 +107 -0
- dlopss/data/a/p6 +38 -0
- dlopss/data/a/p7 +45 -0
- dlopss/data/a/p8 +57 -0
- dlopss/data/b/1.ipynb +1 -0
- dlopss/data/b/1s.ipynb +143 -0
- dlopss/data/b/2a.ipynb +1 -0
- dlopss/data/b/2b.ipynb +257 -0
- dlopss/data/b/3a.ipynb +1 -0
- dlopss/data/b/3b.ipynb +318 -0
- dlopss/data/b/4a.ipynb +1 -0
- dlopss/data/b/4b.ipynb +406 -0
- dlopss/data/b/5a.ipynb +1 -0
- dlopss/data/b/5b.ipynb +1 -0
- dlopss/data/b/6a.ipynb +1 -0
- dlopss/data/b/6b.ipynb +265 -0
- dlopss/data/b/7a.ipynb +1 -0
- dlopss/data/b/7b.ipynb +292 -0
- dlopss/data/b/8.ipynb +1 -0
- dlopss/data/b/__init__.py +1 -0
- dlopss-0.1.0.dist-info/METADATA +55 -0
- dlopss-0.1.0.dist-info/RECORD +32 -0
- dlopss-0.1.0.dist-info/WHEEL +5 -0
- dlopss-0.1.0.dist-info/licenses/LICENSE +21 -0
- dlopss-0.1.0.dist-info/top_level.txt +1 -0
dlopss/__init__.py
ADDED
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
"""
|
|
2
|
+
dlopss
|
|
3
|
+
~~~~~~
|
|
4
|
+
Access bundled Deep Learning course data files.
|
|
5
|
+
|
|
6
|
+
Usage
|
|
7
|
+
-----
|
|
8
|
+
>>> import dlopss
|
|
9
|
+
>>> dlopss.get_data_path() # root data directory
|
|
10
|
+
>>> dlopss.get_a_path() # data/a directory
|
|
11
|
+
>>> dlopss.get_b_path() # data/b directory (notebooks)
|
|
12
|
+
>>> dlopss.list_a_files() # all files in a/
|
|
13
|
+
>>> dlopss.list_notebooks() # all .ipynb files in b/
|
|
14
|
+
"""
|
|
15
|
+
|
|
16
|
+
from importlib.resources import files
|
|
17
|
+
from pathlib import Path
|
|
18
|
+
|
|
19
|
+
|
|
20
|
+
def get_data_path() -> Path:
|
|
21
|
+
"""Return path to the root data/ directory."""
|
|
22
|
+
return Path(str(files("dlopss").joinpath("data")))
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def get_a_path() -> Path:
|
|
26
|
+
"""Return path to the data/a/ directory."""
|
|
27
|
+
return get_data_path() / "a"
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
def get_b_path() -> Path:
|
|
31
|
+
"""Return path to the data/b/ directory (notebooks)."""
|
|
32
|
+
return get_data_path() / "b"
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
def list_a_files() -> list:
|
|
36
|
+
"""Return sorted list of all files in data/a/."""
|
|
37
|
+
return sorted([f for f in get_a_path().iterdir() if f.is_file() and f.name != "__init__.py"])
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
def list_notebooks() -> list:
|
|
41
|
+
"""Return sorted list of all .ipynb files in data/b/."""
|
|
42
|
+
return sorted(get_b_path().glob("*.ipynb"))
|
|
43
|
+
|
|
44
|
+
|
|
45
|
+
__all__ = ["get_data_path", "get_a_path", "get_b_path", "list_a_files", "list_notebooks"]
|
dlopss/data/__init__.py
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
# marks data/ as a package so importlib.resources can locate it
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
# marks data/a as a package so importlib.resources can locate it
|
dlopss/data/a/p1
ADDED
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
import numpy as np
|
|
2
|
+
import matplotlib.pyplot as plt
|
|
3
|
+
X = np.array([[0,0],[0,1],[1,0],[1,1]])
|
|
4
|
+
y = np.array([0,0,0,1])
|
|
5
|
+
df = pd.read_csv("data.csv")
|
|
6
|
+
X = df.iloc[:,:2].values
|
|
7
|
+
y = df.iloc[:,-1].values
|
|
8
|
+
w = np.zeros(2)
|
|
9
|
+
b,lr = 0,0.1
|
|
10
|
+
for _ in range(20):
|
|
11
|
+
for xi,yi in zip(X,y):
|
|
12
|
+
pred = int(np.dot(w,xi)+b >= 0.5)
|
|
13
|
+
w += lr*(yi-pred)*xi
|
|
14
|
+
b += lr*(yi-pred)
|
|
15
|
+
print("Predicted:",[int(np.dot(w,xi)+b >= 0.5) for xi in X])
|
|
16
|
+
print("Actual:",y)
|
|
17
|
+
x1 = np.linspace(X[:,0].min(),X[:,0].max(),100)
|
|
18
|
+
plt.scatter(X[:,0],X[:,1],c=y)
|
|
19
|
+
if w[1] != 0:
|
|
20
|
+
plt.plot(x1,(0.5-b-w[0]*x1)/w[1])
|
|
21
|
+
plt.show()
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
import numpy as np
|
|
25
|
+
import pandas as pd
|
|
26
|
+
import matplotlib.pyplot as plt
|
|
27
|
+
import tensorflow as tf
|
|
28
|
+
import time
|
|
29
|
+
import datetime
|
|
30
|
+
from tensorflow.keras import regularizers
|
dlopss/data/a/p2
ADDED
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
import tensorflow as tf
|
|
2
|
+
import matplotlib.pyplot as plt
|
|
3
|
+
import pandas as pd
|
|
4
|
+
import time
|
|
5
|
+
|
|
6
|
+
# MNIST loading
|
|
7
|
+
train = pd.read_csv("mnist_train(1).csv")
|
|
8
|
+
test = pd.read_csv("mnist_test(1).csv")
|
|
9
|
+
|
|
10
|
+
# Fashion-MNIST loading: Replace the above filenames with:
|
|
11
|
+
# train = pd.read_csv("fashion-mnist_train.csv")
|
|
12
|
+
# test = pd.read_csv("fashion-mnist_test.csv")
|
|
13
|
+
|
|
14
|
+
x_train = train.iloc[:,1:].values.astype('float32').reshape(-1,28,28)/255.0
|
|
15
|
+
y_train = train.iloc[:,0].values
|
|
16
|
+
x_test = test.iloc[:,1:].values.astype('float32').reshape(-1,28,28)/255.0
|
|
17
|
+
y_test = test.iloc[:,0].values
|
|
18
|
+
|
|
19
|
+
print("Training:",x_train.shape)
|
|
20
|
+
print("Testing:",x_test.shape)
|
|
21
|
+
|
|
22
|
+
experiments = [
|
|
23
|
+
('relu',128,64),
|
|
24
|
+
('tanh',128,64),
|
|
25
|
+
('relu',64,32)
|
|
26
|
+
]
|
|
27
|
+
|
|
28
|
+
histories = []
|
|
29
|
+
times = []
|
|
30
|
+
|
|
31
|
+
for act,a,b in experiments:
|
|
32
|
+
model = tf.keras.Sequential([
|
|
33
|
+
tf.keras.layers.Flatten(input_shape=(28,28)),
|
|
34
|
+
tf.keras.layers.Dense(a,activation=act),
|
|
35
|
+
tf.keras.layers.Dense(b,activation=act),
|
|
36
|
+
tf.keras.layers.Dense(10,activation='softmax')
|
|
37
|
+
])
|
|
38
|
+
|
|
39
|
+
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
|
|
40
|
+
|
|
41
|
+
start = time.time()
|
|
42
|
+
h = model.fit(x_train,y_train,epochs=2,batch_size=32,validation_split=0.1,verbose=1)
|
|
43
|
+
elapsed = time.time()-start
|
|
44
|
+
|
|
45
|
+
histories.append(h)
|
|
46
|
+
times.append(elapsed)
|
|
47
|
+
|
|
48
|
+
loss,acc = model.evaluate(x_test,y_test,verbose=0)
|
|
49
|
+
print(act,a,b,"Test Accuracy:",acc)
|
|
50
|
+
print("Training Time:",round(elapsed,2),"seconds")
|
|
51
|
+
|
|
52
|
+
labels = ['ReLU 128-64','Tanh 128-64','ReLU 64-32']
|
|
53
|
+
|
|
54
|
+
# Training and Validation Accuracy
|
|
55
|
+
for h,label in zip(histories,labels):
|
|
56
|
+
plt.plot(h.history['accuracy'],label='Train '+label)
|
|
57
|
+
plt.plot(h.history['val_accuracy'],label='Validation '+label)
|
|
58
|
+
plt.title("Training and Validation Accuracy")
|
|
59
|
+
plt.xlabel("Epochs")
|
|
60
|
+
plt.ylabel("Accuracy")
|
|
61
|
+
plt.legend()
|
|
62
|
+
plt.grid()
|
|
63
|
+
plt.show()
|
|
64
|
+
|
|
65
|
+
# Training and Validation Loss
|
|
66
|
+
for h,label in zip(histories,labels):
|
|
67
|
+
plt.plot(h.history['loss'],label='Train '+label)
|
|
68
|
+
plt.plot(h.history['val_loss'],label='Validation '+label)
|
|
69
|
+
plt.title("Training and Validation Loss")
|
|
70
|
+
plt.xlabel("Epochs")
|
|
71
|
+
plt.ylabel("Loss")
|
|
72
|
+
plt.legend()
|
|
73
|
+
plt.grid()
|
|
74
|
+
plt.show()
|
|
75
|
+
|
|
76
|
+
# Training Time Comparison
|
|
77
|
+
plt.bar(labels,times)
|
|
78
|
+
plt.title("Training Time Comparison")
|
|
79
|
+
plt.xlabel("Model")
|
|
80
|
+
plt.ylabel("Time (seconds)")
|
|
81
|
+
plt.show()
|
dlopss/data/a/p3
ADDED
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
import tensorflow as tf
|
|
2
|
+
import matplotlib.pyplot as plt
|
|
3
|
+
import pandas as pd
|
|
4
|
+
from tensorflow.keras import regularizers
|
|
5
|
+
# Load MNIST dataset
|
|
6
|
+
train = pd.read_csv("mnist_train(1).csv") # Fashion: "fashion-mnist_train.csv"
|
|
7
|
+
test = pd.read_csv("mnist_test(1).csv") # Fashion: "fashion-mnist_test.csv"
|
|
8
|
+
x_train = train.iloc[:,1:].values.astype('float32').reshape(-1,28,28)/255.0
|
|
9
|
+
y_train = train.iloc[:,0].values
|
|
10
|
+
x_test = test.iloc[:,1:].values.astype('float32').reshape(-1,28,28)/255.0
|
|
11
|
+
y_test = test.iloc[:,0].values
|
|
12
|
+
print("Training:",x_train.shape)
|
|
13
|
+
print("Testing:",x_test.shape)
|
|
14
|
+
# Model 1: No Regularization
|
|
15
|
+
m1 = tf.keras.Sequential([
|
|
16
|
+
tf.keras.layers.Flatten(input_shape=(28,28)),
|
|
17
|
+
tf.keras.layers.Dense(128,activation='relu'),
|
|
18
|
+
tf.keras.layers.Dense(10,activation='softmax')
|
|
19
|
+
])
|
|
20
|
+
# Model 2: L2 Regularization
|
|
21
|
+
m2 = tf.keras.Sequential([
|
|
22
|
+
tf.keras.layers.Flatten(input_shape=(28,28)),
|
|
23
|
+
tf.keras.layers.Dense(128,activation='relu',kernel_regularizer=regularizers.l2(0.001)),
|
|
24
|
+
tf.keras.layers.Dense(10,activation='softmax')
|
|
25
|
+
])
|
|
26
|
+
# Model 3: Dropout Regularization
|
|
27
|
+
m3 = tf.keras.Sequential([
|
|
28
|
+
tf.keras.layers.Flatten(input_shape=(28,28)),
|
|
29
|
+
tf.keras.layers.Dense(128,activation='relu'),
|
|
30
|
+
tf.keras.layers.Dropout(0.5),
|
|
31
|
+
tf.keras.layers.Dense(10,activation='softmax')
|
|
32
|
+
])
|
|
33
|
+
histories = []
|
|
34
|
+
for model in [m1,m2,m3]:
|
|
35
|
+
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
|
|
36
|
+
h = model.fit(x_train,y_train,epochs=5,validation_split=0.2,batch_size=32,verbose=0)
|
|
37
|
+
histories.append(h)
|
|
38
|
+
labels = ['No Reg','L2','Dropout']
|
|
39
|
+
# Validation Accuracy Comparison
|
|
40
|
+
for h,label in zip(histories,labels):
|
|
41
|
+
plt.plot(h.history['val_accuracy'],label=label)
|
|
42
|
+
plt.title("Validation Accuracy Comparison")
|
|
43
|
+
plt.xlabel("Epochs")
|
|
44
|
+
plt.ylabel("Validation Accuracy")
|
|
45
|
+
plt.legend()
|
|
46
|
+
plt.grid()
|
|
47
|
+
plt.savefig("practical3_output.png")
|
|
48
|
+
plt.show()
|
|
49
|
+
# Training and Validation Accuracy
|
|
50
|
+
for h,label in zip(histories,labels):
|
|
51
|
+
plt.plot(h.history['accuracy'],label=label+' Train')
|
|
52
|
+
plt.plot(h.history['val_accuracy'],label=label+' Val')
|
|
53
|
+
plt.title("Training and Validation Accuracy")
|
|
54
|
+
plt.xlabel("Epochs")
|
|
55
|
+
plt.ylabel("Accuracy")
|
|
56
|
+
plt.legend()
|
|
57
|
+
plt.grid()
|
|
58
|
+
plt.show()
|
|
59
|
+
# Training and Validation Loss
|
|
60
|
+
for h,label in zip(histories,labels):
|
|
61
|
+
plt.plot(h.history['loss'],label=label+' Train')
|
|
62
|
+
plt.plot(h.history['val_loss'],label=label+' Val')
|
|
63
|
+
plt.title("Training and Validation Loss")
|
|
64
|
+
plt.xlabel("Epochs")
|
|
65
|
+
plt.ylabel("Loss")
|
|
66
|
+
plt.legend()
|
|
67
|
+
plt.grid()
|
|
68
|
+
plt.savefig("practical3_loss.png")
|
|
69
|
+
plt.show()
|
|
70
|
+
# Evaluate all models on test data
|
|
71
|
+
for model,label in zip([m1,m2,m3],labels):
|
|
72
|
+
loss,acc = model.evaluate(x_test,y_test,verbose=0)
|
|
73
|
+
print(label,"Test Accuracy:",acc*100,"%")
|
dlopss/data/a/p4
ADDED
|
@@ -0,0 +1,48 @@
|
|
|
1
|
+
import tensorflow as tf
|
|
2
|
+
import matplotlib.pyplot as plt
|
|
3
|
+
import pandas as pd
|
|
4
|
+
import time
|
|
5
|
+
train = pd.read_csv("mnist_train(1).csv") # Fashion: "fashion-mnist_train.csv"
|
|
6
|
+
test = pd.read_csv("mnist_test(1).csv") # Fashion: "fashion-mnist_test.csv"
|
|
7
|
+
x_train = train.iloc[:,1:].values.astype('float32').reshape(-1,28,28)/255.0
|
|
8
|
+
y_train = train.iloc[:,0].values
|
|
9
|
+
x_test = test.iloc[:,1:].values.astype('float32').reshape(-1,28,28)/255.0
|
|
10
|
+
y_test = test.iloc[:,0].values
|
|
11
|
+
print("Training:",x_train.shape)
|
|
12
|
+
print("Testing:",x_test.shape)
|
|
13
|
+
acts = ['sigmoid','tanh','relu']
|
|
14
|
+
hist,times,grads = {},{},{}
|
|
15
|
+
for act in acts:
|
|
16
|
+
m = tf.keras.Sequential([
|
|
17
|
+
tf.keras.layers.Input((28,28)),
|
|
18
|
+
tf.keras.layers.Flatten(),
|
|
19
|
+
tf.keras.layers.Dense(128,activation=act),
|
|
20
|
+
tf.keras.layers.Dense(64,activation=act),
|
|
21
|
+
tf.keras.layers.Dense(10,activation='softmax')
|
|
22
|
+
])
|
|
23
|
+
m.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
|
|
24
|
+
t = time.time()
|
|
25
|
+
hist[act] = m.fit(x_train,y_train,epochs=5,batch_size=32,validation_split=0.1,verbose=0)
|
|
26
|
+
times[act] = time.time()-t
|
|
27
|
+
print(act,"Accuracy:",m.evaluate(x_test,y_test,verbose=0)[1],"Time:",round(times[act],2))
|
|
28
|
+
with tf.GradientTape() as tape:
|
|
29
|
+
loss = tf.reduce_mean(tf.keras.losses.sparse_categorical_crossentropy(y_train[:32],m(x_train[:32])))
|
|
30
|
+
grads[act] = [tf.norm(g).numpy() for g in tape.gradient(loss,m.trainable_variables) if g is not None]
|
|
31
|
+
for key in ['accuracy','val_accuracy','loss','val_loss']:
|
|
32
|
+
for act in acts:
|
|
33
|
+
plt.plot(hist[act].history[key],label=act)
|
|
34
|
+
plt.title(key.capitalize())
|
|
35
|
+
plt.xlabel("Epochs")
|
|
36
|
+
plt.legend()
|
|
37
|
+
plt.show()
|
|
38
|
+
plt.bar(acts,[times[a] for a in acts])
|
|
39
|
+
plt.title("Training Time")
|
|
40
|
+
plt.ylabel("Seconds")
|
|
41
|
+
plt.show()
|
|
42
|
+
for act in acts:
|
|
43
|
+
plt.plot(grads[act],label=act)
|
|
44
|
+
plt.title("Gradient Flow")
|
|
45
|
+
plt.xlabel("Trainable Variable Index")
|
|
46
|
+
plt.ylabel("Gradient Norm")
|
|
47
|
+
plt.legend()
|
|
48
|
+
plt.show()
|
dlopss/data/a/p5
ADDED
|
@@ -0,0 +1,107 @@
|
|
|
1
|
+
import tensorflow as tf
|
|
2
|
+
import matplotlib.pyplot as plt
|
|
3
|
+
import time
|
|
4
|
+
import pandas as pd # For MNIST CSV loading
|
|
5
|
+
# Load CIFAR-10 dataset
|
|
6
|
+
train_ds = tf.keras.utils.image_dataset_from_directory(
|
|
7
|
+
"dataset/cifar/cifar10/train",
|
|
8
|
+
image_size=(32,32), batch_size=64,
|
|
9
|
+
validation_split=0.1, subset="training", seed=42
|
|
10
|
+
)
|
|
11
|
+
val_ds = tf.keras.utils.image_dataset_from_directory(
|
|
12
|
+
"dataset/cifar/cifar10/train",
|
|
13
|
+
image_size=(32,32), batch_size=64,
|
|
14
|
+
validation_split=0.1, subset="validation", seed=42
|
|
15
|
+
)
|
|
16
|
+
test_ds = tf.keras.utils.image_dataset_from_directory(
|
|
17
|
+
"dataset/cifar/cifar10/test",
|
|
18
|
+
image_size=(32,32), batch_size=64
|
|
19
|
+
)
|
|
20
|
+
print("Classes:",train_ds.class_names)
|
|
21
|
+
# For MNIST: Replace the above CIFAR-10 loading section with:
|
|
22
|
+
# train = pd.read_csv("mnist_train(1).csv")
|
|
23
|
+
# test = pd.read_csv("mnist_test(1).csv")
|
|
24
|
+
# x_train = train.iloc[:,1:].values.astype('float32')/255.0
|
|
25
|
+
# y_train = train.iloc[:,0].values
|
|
26
|
+
# x_test = test.iloc[:,1:].values.astype('float32')/255.0
|
|
27
|
+
# y_test = test.iloc[:,0].values
|
|
28
|
+
# x_train_cnn = x_train.reshape(-1,28,28,1)
|
|
29
|
+
# x_test_cnn = x_test.reshape(-1,28,28,1)
|
|
30
|
+
# Prepare MLP data
|
|
31
|
+
mlp_train = train_ds.map(lambda x,y:(tf.reshape(x/255.0,[-1,3072]),y)).prefetch(1)
|
|
32
|
+
mlp_val = val_ds.map(lambda x,y:(tf.reshape(x/255.0,[-1,3072]),y)).prefetch(1)
|
|
33
|
+
mlp_test = test_ds.map(lambda x,y:(tf.reshape(x/255.0,[-1,3072]),y)).prefetch(1)
|
|
34
|
+
# Prepare CNN data
|
|
35
|
+
cnn_train = train_ds.map(lambda x,y:(x/255.0,y)).prefetch(1)
|
|
36
|
+
cnn_val = val_ds.map(lambda x,y:(x/255.0,y)).prefetch(1)
|
|
37
|
+
cnn_test = test_ds.map(lambda x,y:(x/255.0,y)).prefetch(1)
|
|
38
|
+
# For MNIST: No map() or prefetch() required.
|
|
39
|
+
# Use x_train and y_train directly for MLP.
|
|
40
|
+
# Use x_train_cnn and y_train directly for CNN.
|
|
41
|
+
# Build MLP model
|
|
42
|
+
mlp = tf.keras.Sequential([
|
|
43
|
+
tf.keras.layers.Input((3072,)), # MNIST: Input((784,))
|
|
44
|
+
tf.keras.layers.Dense(256,activation='relu'),
|
|
45
|
+
tf.keras.layers.Dense(10,activation='softmax')
|
|
46
|
+
])
|
|
47
|
+
# Build CNN model with data augmentation
|
|
48
|
+
cnn = tf.keras.Sequential([
|
|
49
|
+
tf.keras.layers.Input((32,32,3)), # MNIST: Input((28,28,1))
|
|
50
|
+
tf.keras.layers.RandomFlip("horizontal"),
|
|
51
|
+
tf.keras.layers.RandomRotation(0.1), # MNIST: RandomRotation(0.05)
|
|
52
|
+
tf.keras.layers.Conv2D(32,(3,3),activation='relu'),
|
|
53
|
+
tf.keras.layers.MaxPooling2D((2,2)),
|
|
54
|
+
tf.keras.layers.Conv2D(64,(3,3),activation='relu'),
|
|
55
|
+
tf.keras.layers.MaxPooling2D((2,2)),
|
|
56
|
+
tf.keras.layers.Flatten(),
|
|
57
|
+
tf.keras.layers.Dense(128,activation='relu'),
|
|
58
|
+
tf.keras.layers.Dense(10,activation='softmax')
|
|
59
|
+
])
|
|
60
|
+
for model in [mlp,cnn]:
|
|
61
|
+
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
|
|
62
|
+
# Train MLP
|
|
63
|
+
start = time.time()
|
|
64
|
+
h1 = mlp.fit(mlp_train,epochs=5,validation_data=mlp_val,verbose=0)
|
|
65
|
+
mlp_time = time.time()-start
|
|
66
|
+
mlp_loss,mlp_acc = mlp.evaluate(mlp_test,verbose=0)
|
|
67
|
+
print("MLP Accuracy:",mlp_acc*100,"%")
|
|
68
|
+
print("MLP Training Time:",round(mlp_time,2),"seconds")
|
|
69
|
+
# For MNIST MLP training:
|
|
70
|
+
# h1 = mlp.fit(x_train,y_train,epochs=5,batch_size=64,validation_split=0.1)
|
|
71
|
+
# mlp_loss,mlp_acc = mlp.evaluate(x_test,y_test,verbose=0)
|
|
72
|
+
# Train CNN
|
|
73
|
+
start = time.time()
|
|
74
|
+
h2 = cnn.fit(cnn_train,epochs=5,validation_data=cnn_val,verbose=0)
|
|
75
|
+
cnn_time = time.time()-start
|
|
76
|
+
cnn_loss,cnn_acc = cnn.evaluate(cnn_test,verbose=0)
|
|
77
|
+
print("CNN Accuracy:",cnn_acc*100,"%")
|
|
78
|
+
print("CNN Training Time:",round(cnn_time,2),"seconds")
|
|
79
|
+
# For MNIST CNN training:
|
|
80
|
+
# h2 = cnn.fit(x_train_cnn,y_train,epochs=5,batch_size=64,validation_split=0.1)
|
|
81
|
+
# cnn_loss,cnn_acc = cnn.evaluate(x_test_cnn,y_test,verbose=0)
|
|
82
|
+
# Compare accuracy
|
|
83
|
+
plt.bar(['MLP','CNN'],[mlp_acc*100,cnn_acc*100])
|
|
84
|
+
plt.title("MLP vs CNN Accuracy")
|
|
85
|
+
plt.ylabel("Accuracy (%)")
|
|
86
|
+
plt.show()
|
|
87
|
+
# Compare training time
|
|
88
|
+
plt.bar(['MLP','CNN'],[mlp_time,cnn_time])
|
|
89
|
+
plt.title("Training Time Comparison")
|
|
90
|
+
plt.ylabel("Time (seconds)")
|
|
91
|
+
plt.show()
|
|
92
|
+
# Plot validation accuracy
|
|
93
|
+
plt.plot(h1.history['val_accuracy'],label='MLP')
|
|
94
|
+
plt.plot(h2.history['val_accuracy'],label='CNN')
|
|
95
|
+
plt.title("Validation Accuracy")
|
|
96
|
+
plt.xlabel("Epochs")
|
|
97
|
+
plt.ylabel("Accuracy")
|
|
98
|
+
plt.legend()
|
|
99
|
+
plt.show()
|
|
100
|
+
# Plot validation loss
|
|
101
|
+
plt.plot(h1.history['val_loss'],label='MLP')
|
|
102
|
+
plt.plot(h2.history['val_loss'],label='CNN')
|
|
103
|
+
plt.title("Validation Loss")
|
|
104
|
+
plt.xlabel("Epochs")
|
|
105
|
+
plt.ylabel("Loss")
|
|
106
|
+
plt.legend()
|
|
107
|
+
plt.show()
|
dlopss/data/a/p6
ADDED
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
import tensorflow as tf
|
|
2
|
+
import matplotlib.pyplot as plt
|
|
3
|
+
import pandas as pd
|
|
4
|
+
df = pd.read_csv("IMDB Dataset(2).csv")
|
|
5
|
+
df['sentiment'] = df['sentiment'].map({'positive':1,'negative':0})
|
|
6
|
+
train = df.sample(frac=0.8,random_state=42)
|
|
7
|
+
test = df.drop(train.index)
|
|
8
|
+
x_train = train['review'].astype(str).values
|
|
9
|
+
y_train = train['sentiment'].values
|
|
10
|
+
x_test = test['review'].astype(str).values
|
|
11
|
+
y_test = test['sentiment'].values
|
|
12
|
+
tokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=5000)
|
|
13
|
+
tokenizer.fit_on_texts(x_train)
|
|
14
|
+
x_train = tokenizer.texts_to_sequences(x_train)
|
|
15
|
+
x_test = tokenizer.texts_to_sequences(x_test)
|
|
16
|
+
x_train = tf.keras.preprocessing.sequence.pad_sequences(x_train,maxlen=100)
|
|
17
|
+
x_test = tf.keras.preprocessing.sequence.pad_sequences(x_test,maxlen=100)
|
|
18
|
+
model = tf.keras.Sequential([
|
|
19
|
+
tf.keras.layers.Embedding(5000,64),
|
|
20
|
+
tf.keras.layers.SimpleRNN(32), # Changed from LSTM(64) to SimpleRNN(32)
|
|
21
|
+
tf.keras.layers.Dense(1,activation='sigmoid')
|
|
22
|
+
])
|
|
23
|
+
model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])
|
|
24
|
+
h = model.fit(x_train,y_train,epochs=3,batch_size=64,validation_split=0.1)
|
|
25
|
+
print("Test Accuracy:",model.evaluate(x_test,y_test,verbose=0)[1]*100,"%")
|
|
26
|
+
plt.plot(h.history['accuracy'],label='Train')
|
|
27
|
+
plt.plot(h.history['val_accuracy'],label='Validation')
|
|
28
|
+
plt.title("Simple RNN IMDB Accuracy")
|
|
29
|
+
plt.xlabel("Epochs")
|
|
30
|
+
plt.legend()
|
|
31
|
+
plt.show()
|
|
32
|
+
for i in range(3):
|
|
33
|
+
p = model.predict(x_test[i:i+1],verbose=0)[0][0]
|
|
34
|
+
print("Review",i+1,":","Positive" if p>=0.5 else "Negative",round(p,2))
|
|
35
|
+
review = ["This movie was amazing and I really enjoyed it"]
|
|
36
|
+
seq = tf.keras.preprocessing.sequence.pad_sequences(tokenizer.texts_to_sequences(review),maxlen=100)
|
|
37
|
+
p = model.predict(seq,verbose=0)[0][0]
|
|
38
|
+
print("Prediction:", "Positive" if p>=0.5 else "Negative")
|
dlopss/data/a/p7
ADDED
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
import tensorflow as tf
|
|
2
|
+
import matplotlib.pyplot as plt
|
|
3
|
+
train_ds = tf.keras.utils.image_dataset_from_directory(
|
|
4
|
+
"dataset/cats_and_dogs_filtered/train",
|
|
5
|
+
image_size=(160,160), batch_size=32
|
|
6
|
+
)
|
|
7
|
+
val_ds = tf.keras.utils.image_dataset_from_directory(
|
|
8
|
+
"dataset/cats_and_dogs_filtered/validation",
|
|
9
|
+
image_size=(160,160), batch_size=32
|
|
10
|
+
)
|
|
11
|
+
print("Classes:", train_ds.class_names)
|
|
12
|
+
preprocess = tf.keras.applications.vgg16.preprocess_input #resnet50.preprocess_input
|
|
13
|
+
train_ds = train_ds.map(lambda x,y: (preprocess(x),y)).prefetch(1)
|
|
14
|
+
val_ds = val_ds.map(lambda x,y: (preprocess(x),y)).prefetch(1)
|
|
15
|
+
base = tf.keras.applications.VGG16(weights='imagenet', include_top=False, input_shape=(160,160,3)) #ResNet50
|
|
16
|
+
base.trainable = False
|
|
17
|
+
model = tf.keras.Sequential([
|
|
18
|
+
base,
|
|
19
|
+
tf.keras.layers.GlobalAveragePooling2D(),
|
|
20
|
+
tf.keras.layers.Dense(128, activation='relu'),
|
|
21
|
+
tf.keras.layers.Dense(1, activation='sigmoid')
|
|
22
|
+
])
|
|
23
|
+
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
|
|
24
|
+
h1 = model.fit(train_ds, validation_data=val_ds, epochs=3)
|
|
25
|
+
loss1, acc1 = model.evaluate(val_ds)
|
|
26
|
+
print("Frozen VGG16 Accuracy:", acc1*100, "%")
|
|
27
|
+
base.trainable = True
|
|
28
|
+
for layer in base.layers[:-4]:
|
|
29
|
+
layer.trainable = False
|
|
30
|
+
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.00001), loss='binary_crossentropy', metrics=['accuracy'])
|
|
31
|
+
h2 = model.fit(train_ds, validation_data=val_ds, epochs=3)
|
|
32
|
+
loss2, acc2 = model.evaluate(val_ds)
|
|
33
|
+
print("Fine-tuned VGG16 Accuracy:", acc2*100, "%")
|
|
34
|
+
plt.bar(['Frozen VGG16','Fine-tuned VGG16'], [acc1*100,acc2*100])
|
|
35
|
+
plt.ylabel("Accuracy (%)")
|
|
36
|
+
plt.title("VGG16 Performance Comparison")
|
|
37
|
+
plt.show()
|
|
38
|
+
plt.plot(h1.history['val_accuracy'], label='Frozen VGG16')
|
|
39
|
+
plt.plot([x+3 for x in range(3)], h2.history['val_accuracy'], label='Fine-tuned VGG16')
|
|
40
|
+
plt.axvline(x=2, color='r', linestyle='--', label='Fine-tuning')
|
|
41
|
+
plt.xlabel("Epochs")
|
|
42
|
+
plt.ylabel("Validation Accuracy")
|
|
43
|
+
plt.title("VGG16 Accuracy Comparison")
|
|
44
|
+
plt.legend()
|
|
45
|
+
plt.show()
|
dlopss/data/a/p8
ADDED
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
|
|
2
|
+
import tensorflow as tf
|
|
3
|
+
import matplotlib.pyplot as plt
|
|
4
|
+
import pandas as pd
|
|
5
|
+
import time
|
|
6
|
+
train = pd.read_csv("mnist_train(1).csv")
|
|
7
|
+
test = pd.read_csv("mnist_test(1).csv")
|
|
8
|
+
x_train = train.iloc[:,1:].values.astype('float32') / 255.0
|
|
9
|
+
y_train = train.iloc[:,0].values
|
|
10
|
+
x_test = test.iloc[:,1:].values.astype('float32') / 255.0
|
|
11
|
+
y_test = test.iloc[:,0].values
|
|
12
|
+
print("Training:", x_train.shape)
|
|
13
|
+
print("Testing:", x_test.shape)
|
|
14
|
+
experiments = [
|
|
15
|
+
("exp1",0.001,128,32,1),
|
|
16
|
+
("exp2",0.0001,128,32,1),
|
|
17
|
+
("exp3",0.01,128,32,1),
|
|
18
|
+
("exp4",0.001,64,32,1),
|
|
19
|
+
("exp5",0.001,128,64,1),
|
|
20
|
+
("exp6",0.001,128,32,2)
|
|
21
|
+
]
|
|
22
|
+
results = []
|
|
23
|
+
best_acc = 0
|
|
24
|
+
best_config = ""
|
|
25
|
+
for name,lr,batch,units,layers in experiments:
|
|
26
|
+
model = tf.keras.Sequential([tf.keras.layers.Input((784,))])
|
|
27
|
+
for i in range(layers):
|
|
28
|
+
model.add(tf.keras.layers.Dense(units,activation='relu'))
|
|
29
|
+
model.add(tf.keras.layers.Dense(10,activation='softmax'))
|
|
30
|
+
model.compile(optimizer=tf.keras.optimizers.Adam(lr),loss='sparse_categorical_crossentropy',metrics=['accuracy'])
|
|
31
|
+
log = tf.keras.callbacks.TensorBoard(log_dir=f"logs/{name}_{time.strftime('%H%M%S')}")
|
|
32
|
+
start = time.time()
|
|
33
|
+
h = model.fit(x_train,y_train,epochs=5,batch_size=batch,validation_split=0.1,callbacks=[log],verbose=0)
|
|
34
|
+
test_acc = model.evaluate(x_test,y_test,verbose=0)[1]
|
|
35
|
+
elapsed = time.time()-start
|
|
36
|
+
results.append([name,lr,batch,units,layers,test_acc,elapsed])
|
|
37
|
+
print(name,"Train:",round(h.history['accuracy'][-1],3),"Val:",round(h.history['val_accuracy'][-1],3),"Test:",round(test_acc,3),"Time:",round(elapsed,2))
|
|
38
|
+
if h.history['val_accuracy'][-1] > best_acc:
|
|
39
|
+
best_acc = h.history['val_accuracy'][-1]
|
|
40
|
+
best_config = name
|
|
41
|
+
print("\nREPORT:")
|
|
42
|
+
print("Compared 6 MLP configurations.")
|
|
43
|
+
print("Parameters: Learning rate, batch size, units and layers.")
|
|
44
|
+
print("Best configuration:",best_config)
|
|
45
|
+
print("Best Validation Accuracy:",round(best_acc,3))
|
|
46
|
+
print("TensorBoard is used to visualize training performance.")
|
|
47
|
+
plt.bar([r[0] for r in results],[r[5]*100 for r in results])
|
|
48
|
+
plt.title("Accuracy Comparison")
|
|
49
|
+
plt.xlabel("Experiments")
|
|
50
|
+
plt.ylabel("Accuracy (%)")
|
|
51
|
+
plt.show()
|
|
52
|
+
plt.bar([r[0] for r in results],[r[6] for r in results])
|
|
53
|
+
plt.title("Training Time Comparison")
|
|
54
|
+
plt.xlabel("Experiments")
|
|
55
|
+
plt.ylabel("Time (seconds)")
|
|
56
|
+
plt.show()
|
|
57
|
+
print("\nRun: tensorboard --logdir=logs")
|
dlopss/data/b/1.ipynb
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"cells":[{"cell_type":"code","execution_count":1,"id":"a9511e8c-7adb-468f-917f-8eca13e44799","metadata":{"id":"a9511e8c-7adb-468f-917f-8eca13e44799","executionInfo":{"status":"ok","timestamp":1794901316006,"user_tz":-330,"elapsed":66,"user":{"displayName":"Riya Patil","userId":"14071044496642670277"}}},"outputs":[],"source":["# Assignment 1\n","# Implement a Perceptron from Scratch\n","# o Implement a single-layer perceptron using NumPy.\n","# o Train it on linearly separable data (e.g., AND/OR gate or\n","# synthetic dataset).\n","# o Visualize decision boundary."]},{"cell_type":"code","execution_count":2,"id":"a49b4ee1-3e3e-4fb3-9598-b3de354d6d7c","metadata":{"id":"a49b4ee1-3e3e-4fb3-9598-b3de354d6d7c","executionInfo":{"status":"ok","timestamp":1794901369977,"user_tz":-330,"elapsed":47,"user":{"displayName":"Riya Patil","userId":"14071044496642670277"}}},"outputs":[],"source":["# Cell 1: Import libraries and create dataset\n","\n","import numpy as np\n","import matplotlib.pyplot as plt\n","\n","X = np.array([[0,0],[0,1],[1,0],[1,1]])\n","y = np.array([0,1,1,1])"]},{"cell_type":"code","execution_count":3,"id":"13962b9d-2515-47f4-9a57-b4696cad89ec","metadata":{"id":"13962b9d-2515-47f4-9a57-b4696cad89ec","outputId":"24bc8f23-403e-4d21-97dc-fe5f1ec78650","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1794901371350,"user_tz":-330,"elapsed":17,"user":{"displayName":"Riya Patil","userId":"14071044496642670277"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Predictions: [0, 1, 1, 1]\n","Actual: [0 1 1 1]\n"]}],"source":["# Cell 2: Implement and train Perceptron\n","\n","w = np.zeros(2)\n","b = 0\n","lr = 0.1\n","\n","for epoch in range(10):\n"," for i in range(4):\n"," output = 1 if np.dot(X[i],w) + b >= 1 else 0\n"," error = y[i] - output\n"," w += lr * error * X[i]\n"," b += lr * error\n","\n","print(\"Predictions: \",[1 if np.dot(x,w) + b >= 1 else 0 for x in X])\n","print(\"Actual: \",y)"]},{"cell_type":"code","execution_count":4,"id":"f0827625-0c6f-422f-856a-4d4de38408c1","metadata":{"id":"f0827625-0c6f-422f-856a-4d4de38408c1","outputId":"af209515-0e69-4f4b-ccbe-1487c4026b98","colab":{"base_uri":"https://localhost:8080/","height":472},"executionInfo":{"status":"ok","timestamp":1794901374017,"user_tz":-330,"elapsed":491,"user":{"displayName":"Riya Patil","userId":"14071044496642670277"}}},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["# Cell 3: Visualize decision boundary\n","\n","plt.scatter(X[:,0], X[:,1], c=y, cmap='bwr', s=100)\n","x = np.linspace(-0.5,1.5,100)\n","plt.plot(x, (1 - b - w[0]*x) / w[1])\n","plt.xlabel(\"Input 1\")\n","plt.ylabel(\"Input 2\")\n","plt.title(\"Perceptron Decision Boundary (AND Gate)\")\n","plt.grid()\n","plt.show()"]}],"metadata":{"kernelspec":{"display_name":"Python 3 (ipykernel)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.11.18"},"colab":{"provenance":[]}},"nbformat":4,"nbformat_minor":5}
|