_test_keras_cnn.test_keras_losses() - Code Metrics - Inspection of "Merge branch 'master' into development" - SimonBlanke/Hyperactive - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 872a28...3bf564 )

by Simon

created 2019-09-12 15:32 UTC

_test_keras_cnn.test_keras_losses() A

↳ Parent: _test_keras_cnn

Complexity

Conditions

Size

Total Lines	29
Code Lines	24

Duplication

Lines	29
Ratio	100 %

Importance

Changes

Metric	Value
eloc	24
dl	29
loc	29
rs	9.304
c	0
b	0
f	0
cc	2
nop	0

from keras.datasets import cifar10
from keras.utils import to_categorical

(X_train, y_train), (X_test, y_test) = cifar10.load_data()

X = X_train[0:1000]
y = y_train[0:1000]

y = to_categorical(y, 10)


search_config = {
    "keras.compile.0": {"loss": ["categorical_crossentropy"], "optimizer": ["adam"]},
    "keras.fit.0": {"epochs": [1], "batch_size": [1000], "verbose": [1]},
    "keras.layers.Conv2D.1": {
        "filters": [32, 64, 128],
        "kernel_size": [3],
        "activation": ["relu"],
    },
    "keras.layers.MaxPooling2D.2": {"pool_size": [(4, 4)]},
    "keras.layers.Flatten.3": {},
    "keras.layers.Dense.4": {"units": [10], "activation": ["softmax"]},
}


def test_keras():
    from hyperactive import HillClimbingOptimizer

    opt = HillClimbingOptimizer(search_config, 1)
    opt.fit(X, y)
    opt.predict(X)
    opt.score(X, y)


def test_keras_scores():

    from hyperactive import RandomSearchOptimizer

    ml_scores = [
        "accuracy",
        "binary_accuracy",
        "categorical_accuracy",
        # "sparse_categorical_accuracy",
        "top_k_categorical_accuracy",
        # "sparse_top_k_categorical_accuracy",
    ]

    for score in ml_scores:
        opt = RandomSearchOptimizer(search_config, 1, metric=score)
        assert opt._config_.metric == score
        opt.fit(X, y)
        assert opt._config_.metric == score
        opt.predict(X)
        assert opt._config_.metric == score
        opt.score(X, y)
        assert opt._config_.metric == score


def test_keras_losses():

    from hyperactive import RandomSearchOptimizer

    ml_losses = [
        "mean_squared_error",
        "mean_absolute_error",
        "mean_absolute_percentage_error",
        "mean_squared_logarithmic_error",
        "squared_hinge",
        "hinge",
        # "categorical_hinge",
        "logcosh",
        "categorical_crossentropy",
        # "sparse_categorical_crossentropy",
        "binary_crossentropy",
        "kullback_leibler_divergence",
        "poisson",
        "cosine_proximity",
    ]

    for loss in ml_losses:
        opt = RandomSearchOptimizer(search_config, 1, metric=loss)
        assert opt._config_.metric == loss
        opt.fit(X, y)
        assert opt._config_.metric == loss
        opt.predict(X)
        assert opt._config_.metric == loss
        opt.score(X, y)
        assert opt._config_.metric == loss


def test_keras_n_jobs():
    from hyperactive import HillClimbingOptimizer

    n_jobs_list = [1, 2, 3, 4]
    for n_jobs in n_jobs_list:
        opt = HillClimbingOptimizer(search_config, 1, n_jobs=n_jobs)
        opt.fit(X, y)
        opt.predict(X)
        opt.score(X, y)


def test_keras_n_iter():
    from hyperactive import HillClimbingOptimizer

    n_iter_list = [0, 1, 3]
    for n_iter in n_iter_list:
        opt = HillClimbingOptimizer(search_config, n_iter)
        opt.fit(X, y)
        opt.predict(X)
        opt.score(X, y)


def test_keras_cv():
    from hyperactive import HillClimbingOptimizer

    cv_list = [0.1, 0.5, 0.9, 2]
    for cv in cv_list:
        opt = HillClimbingOptimizer(search_config, 1, cv=cv)
        opt.fit(X, y)
        opt.predict(X)
        opt.score(X, y)


def test_keras_verbosity():
    from hyperactive import HillClimbingOptimizer

    verbosity_list = [0, 1, 2]
    for verbosity in verbosity_list:
        opt = HillClimbingOptimizer(search_config, 1, verbosity=verbosity)
        opt.fit(X, y)
        opt.predict(X)
        opt.score(X, y)


def test_keras_random_state():
    from hyperactive import HillClimbingOptimizer

    random_state_list = [None, 0, 1, 2]
    for random_state in random_state_list:
        opt = HillClimbingOptimizer(search_config, 1, random_state=random_state)
        opt.fit(X, y)
        opt.predict(X)
        opt.score(X, y)


def test_keras_warm_start():
    from hyperactive import HillClimbingOptimizer

    warm_start = {
        "keras.compile.0": {
            "loss": ["categorical_crossentropy"],
            "optimizer": ["adam"],
        },
        "keras.fit.0": {"epochs": [1], "batch_size": [1000], "verbose": [1]},
        "keras.layers.Conv2D.1": {
            "filters": [64],
            "kernel_size": [3],
            "activation": ["relu"],
        },
        "keras.layers.MaxPooling2D.2": {"pool_size": [(4, 4)]},
        "keras.layers.Flatten.3": {},
        "keras.layers.Dense.4": {"units": [10], "activation": ["softmax"]},
    }

    warm_start_list = [None, warm_start]
    for warm_start in warm_start_list:
        opt = HillClimbingOptimizer(search_config, 1, warm_start=warm_start)
        opt.fit(X, y)
        opt.predict(X)
        opt.score(X, y)


def test_keras_memory():
    from hyperactive import HillClimbingOptimizer

    memory_list = [False, True]
    for memory in memory_list:
        opt = HillClimbingOptimizer(search_config, 1, memory=memory)
        opt.fit(X, y)
        opt.predict(X)
        opt.score(X, y)


def test_keras_scatter_init():
    from hyperactive import HillClimbingOptimizer

    scatter_init_list = [False, 2, 3, 4]
    for scatter_init in scatter_init_list:
        opt = HillClimbingOptimizer(search_config, 1, scatter_init=scatter_init)
        opt.fit(X, y)
        opt.predict(X)
        opt.score(X, y)


1		from keras.datasets import cifar10
2		from keras.utils import to_categorical
3
4		(X_train, y_train), (X_test, y_test) = cifar10.load_data()
5
6		X = X_train[0:1000]
7		y = y_train[0:1000]
8
9		y = to_categorical(y, 10)
10
11
12		search_config = {
13		"keras.compile.0": {"loss": ["categorical_crossentropy"], "optimizer": ["adam"]},
14		"keras.fit.0": {"epochs": [1], "batch_size": [1000], "verbose": [1]},
15		"keras.layers.Conv2D.1": {
16		"filters": [32, 64, 128],
17		"kernel_size": [3],
18		"activation": ["relu"],
19		},
20		"keras.layers.MaxPooling2D.2": {"pool_size": [(4, 4)]},
21		"keras.layers.Flatten.3": {},
22		"keras.layers.Dense.4": {"units": [10], "activation": ["softmax"]},
23		}
24
25
26		def test_keras():
27		from hyperactive import HillClimbingOptimizer
28
29		opt = HillClimbingOptimizer(search_config, 1)
30		opt.fit(X, y)
31		opt.predict(X)
32		opt.score(X, y)
33
34
35	View Code Duplication	def test_keras_scores():
		0 ignored issues – show Duplication introduced 2019-09-04 05:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
36		from hyperactive import RandomSearchOptimizer
37
38		ml_scores = [
39		"accuracy",
40		"binary_accuracy",
41		"categorical_accuracy",
42		# "sparse_categorical_accuracy",
43		"top_k_categorical_accuracy",
44		# "sparse_top_k_categorical_accuracy",
45		]
46
47		for score in ml_scores:
48		opt = RandomSearchOptimizer(search_config, 1, metric=score)
49		assert opt._config_.metric == score
50		opt.fit(X, y)
51		assert opt._config_.metric == score
52		opt.predict(X)
53		assert opt._config_.metric == score
54		opt.score(X, y)
55		assert opt._config_.metric == score
56
57
58	View Code Duplication	def test_keras_losses():
		0 ignored issues – show Duplication introduced 2019-09-04 05:46 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
59		from hyperactive import RandomSearchOptimizer
60
61		ml_losses = [
62		"mean_squared_error",
63		"mean_absolute_error",
64		"mean_absolute_percentage_error",
65		"mean_squared_logarithmic_error",
66		"squared_hinge",
67		"hinge",
68		# "categorical_hinge",
69		"logcosh",
70		"categorical_crossentropy",
71		# "sparse_categorical_crossentropy",
72		"binary_crossentropy",
73		"kullback_leibler_divergence",
74		"poisson",
75		"cosine_proximity",
76		]
77
78		for loss in ml_losses:
79		opt = RandomSearchOptimizer(search_config, 1, metric=loss)
80		assert opt._config_.metric == loss
81		opt.fit(X, y)
82		assert opt._config_.metric == loss
83		opt.predict(X)
84		assert opt._config_.metric == loss
85		opt.score(X, y)
86		assert opt._config_.metric == loss
87
88
89		def test_keras_n_jobs():
90		from hyperactive import HillClimbingOptimizer
91
92		n_jobs_list = [1, 2, 3, 4]
93		for n_jobs in n_jobs_list:
94		opt = HillClimbingOptimizer(search_config, 1, n_jobs=n_jobs)
95		opt.fit(X, y)
96		opt.predict(X)
97		opt.score(X, y)
98
99
100		def test_keras_n_iter():
101		from hyperactive import HillClimbingOptimizer
102
103		n_iter_list = [0, 1, 3]
104		for n_iter in n_iter_list:
105		opt = HillClimbingOptimizer(search_config, n_iter)
106		opt.fit(X, y)
107		opt.predict(X)
108		opt.score(X, y)
109
110
111		def test_keras_cv():
112		from hyperactive import HillClimbingOptimizer
113
114		cv_list = [0.1, 0.5, 0.9, 2]
115		for cv in cv_list:
116		opt = HillClimbingOptimizer(search_config, 1, cv=cv)
117		opt.fit(X, y)
118		opt.predict(X)
119		opt.score(X, y)
120
121
122		def test_keras_verbosity():
123		from hyperactive import HillClimbingOptimizer
124
125		verbosity_list = [0, 1, 2]
126		for verbosity in verbosity_list:
127		opt = HillClimbingOptimizer(search_config, 1, verbosity=verbosity)
128		opt.fit(X, y)
129		opt.predict(X)
130		opt.score(X, y)
131
132
133		def test_keras_random_state():
134		from hyperactive import HillClimbingOptimizer
135
136		random_state_list = [None, 0, 1, 2]
137		for random_state in random_state_list:
138		opt = HillClimbingOptimizer(search_config, 1, random_state=random_state)
139		opt.fit(X, y)
140		opt.predict(X)
141		opt.score(X, y)
142
143
144		def test_keras_warm_start():
145		from hyperactive import HillClimbingOptimizer
146
147		warm_start = {
148		"keras.compile.0": {
149		"loss": ["categorical_crossentropy"],
150		"optimizer": ["adam"],
151		},
152		"keras.fit.0": {"epochs": [1], "batch_size": [1000], "verbose": [1]},
153		"keras.layers.Conv2D.1": {
154		"filters": [64],
155		"kernel_size": [3],
156		"activation": ["relu"],
157		},
158		"keras.layers.MaxPooling2D.2": {"pool_size": [(4, 4)]},
159		"keras.layers.Flatten.3": {},
160		"keras.layers.Dense.4": {"units": [10], "activation": ["softmax"]},
161		}
162
163		warm_start_list = [None, warm_start]
164		for warm_start in warm_start_list:
165		opt = HillClimbingOptimizer(search_config, 1, warm_start=warm_start)
166		opt.fit(X, y)
167		opt.predict(X)
168		opt.score(X, y)
169
170
171		def test_keras_memory():
172		from hyperactive import HillClimbingOptimizer
173
174		memory_list = [False, True]
175		for memory in memory_list:
176		opt = HillClimbingOptimizer(search_config, 1, memory=memory)
177		opt.fit(X, y)
178		opt.predict(X)
179		opt.score(X, y)
180
181
182		def test_keras_scatter_init():
183		from hyperactive import HillClimbingOptimizer
184
185		scatter_init_list = [False, 2, 3, 4]
186		for scatter_init in scatter_init_list:
187		opt = HillClimbingOptimizer(search_config, 1, scatter_init=scatter_init)
188		opt.fit(X, y)
189		opt.predict(X)
190		opt.score(X, y)
191

SimonBlanke / Hyperactive

Push — master ( 872a28...3bf564 )

_test_keras_cnn.test_keras_losses() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like