SDA.predict() - Code Metrics - TinghuiWang/pyActLearn - Measure and Improve Code Quality continuously with Scrutinizer

SDA.predict() A
last analyzed 2018-03-13 15:38 UTC

↳ Parent: SDA

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
c	1
b	0
f	0
dl	0
loc	8
rs	9.4285

import logging
import numpy as np
import tensorflow as tf
from .layers import AutoencoderLayer, HiddenLayer, SoftmaxLayer
from .injectors import BatchInjector
from .criterion import MonitorBased, ConstIterations

logger = logging.getLogger(__name__)


class SDA:
    """Stacked Auto-encoder

    Args:
        num_features (:obj:`int`): Number of features.
        num_classes (:obj:`int`): Number of classes.
        layers (:obj:`list` of :obj:`int`): Series of hidden auto-encoder layers.
        encode_optimizer: Optimizer used for auto-encoding process.
        tuning_optimizer: Optimizer used for fine tuning.

    Attributes:
        num_features (:obj:`int`): Number of features.
        num_classes (:obj:`int`): Number of classes.
        x (:obj:`tensorflow.placeholder`): Input placeholder.
        y_ (:obj:`tensorflow.placeholder`): Output placeholder.
        inner_layers (:obj:`list`): List of auto-encoder hidden layers.

    """
    def __init__(self, num_features, num_classes, layers, encode_optimizer=None, tuning_optimizer=None):
        self.num_features = num_features
        self.num_classes = num_classes
        with tf.name_scope('input'):
            self.x = tf.placeholder(tf.float32, shape=[None, num_features], name='input_x')
            self.y_ = tf.placeholder(tf.float32, shape=[None, num_classes], name='input_y')
        self.inner_layers = []
        self.summaries = []
        self.encode_opts = []
        if encode_optimizer is None:
            self.encode_optimizer = tf.train.AdamOptimizer()
        else:
            self.encode_optimizer = encode_optimizer
        if tuning_optimizer is None:
            self.tuning_optimizer = tf.train.AdamOptimizer()
        else:
            self.tuning_optimizer = tuning_optimizer
        # Create Layers
        for i in range(len(layers)):
            if i == 0:

                # First Layer
                self.inner_layers.append(
                    AutoencoderLayer(num_features, layers[i], x=self.x, name=('Hidden%d' % i))
                )
            else:
                # inner Layer
                self.inner_layers.append(
                    AutoencoderLayer(layers[i-1], layers[i], x=self.inner_layers[i-1].y, name=('Hidden%d' % i))
                )
            self.summaries += self.inner_layers[i].summaries
            self.encode_opts.append(
                self.encode_optimizer.minimize(self.inner_layers[i].encode_loss,
                                               var_list=self.inner_layers[i].variables)
            )
        if num_classes == 1:

            # Output Layers
            self.output_layer = HiddenLayer(layers[len(layers) - 1], num_classes, x=self.inner_layers[len(layers)-1].y,
                                            name='Output', activation_fn=tf.sigmoid)
            # Predicted Probability
            self.y = self.output_layer.y
            self.y_class = tf.cast(tf.greater_equal(self.y, 0.5), tf.float32)
            # Loss
            self.loss = tf.reduce_mean(
                tf.nn.sigmoid_cross_entropy_with_logits(self.output_layer.logits, self.y_,
                                                        name='SigmoidCrossEntropyLoss')
            )
            self.correct_prediction = tf.equal(self.y_class, self.y_)
            self.accuracy = tf.reduce_mean(tf.cast(self.correct_prediction, tf.float32))
        else:
            # Output Layers
            self.output_layer = SoftmaxLayer(layers[len(layers) - 1], num_classes, x=self.inner_layers[len(layers)-1].y,
                                             name='OutputLayer')
            # Predicted Probability
            self.y = self.output_layer.y
            self.y_class = tf.argmax(self.y, 1)
            # Loss
            self.loss = tf.reduce_mean(
                tf.nn.softmax_cross_entropy_with_logits(logits=self.output_layer.logits, labels=self.y_,
                                                        name='SoftmaxCrossEntropyLoss')
            )
            self.correct_prediction = tf.equal(self.y_class, tf.argmax(self.y_, 1))
            self.accuracy = tf.reduce_mean(tf.cast(self.correct_prediction, tf.float32))
        self.summaries.append(tf.summary.scalar('cross_entropy', self.loss))
        self.summaries.append(tf.summary.scalar('accuracy', self.accuracy))
        self.summaries += self.output_layer.summaries
        with tf.name_scope('train'):
            self.fine_tuning = self.tuning_optimizer.minimize(self.loss)
        self.merged = tf.summary.merge(self.summaries)
        self.sess = None

    def fit(self, x, y, batch_size=100,
            pretrain_iter_num=100, pretrain_criterion='const_iterations',
            tuning_iter_num=100, tuning_criterion='const_iterations',
            summaries_dir=None, test_x=None, test_y=None, summary_interval=10,
            session=None):
        """Fit the model to the dataset

        Args:
            x (:obj:`numpy.ndarray`): Input features of shape (num_samples, num_features).
            y (:obj:`numpy.ndarray`): Corresponding Labels of shape (num_samples) for binary classification,
                or (num_samples, num_classes) for multi-class classification.
            batch_size (:obj:`int`): Batch size used in gradient descent.
            pretrain_iter_num (:obj:`int`): Number of const iterations or search depth for monitor based stopping
                criterion in pre-training stage
            pretrain_criterion (:obj:`str`): Stopping criteria in pre-training stage ('const_iterations' or
                'monitor_based')
            tuning_iter_num (:obj:`int`): Number of const iterations or search depth for monitor based stopping
                criterion in fine-tuning stage
            tuning_criterion (:obj:`str`): Stopping criteria in fine-tuning stage ('const_iterations' or
                'monitor_based')
            summaries_dir (:obj:`str`): Path of the directory to store summaries and saved values.
            summary_interval (:obj:`int`): The step interval to export variable summaries.
            test_x (:obj:`numpy.ndarray`): Test feature array used for monitoring training progress.
            test_y (:obj:`numpy.ndarray): Test label array used for monitoring training progress.
            session (:obj:`tensorflow.Session`): Session to run training functions.
        """
        if session is None:
            if self.sess is None:
                session = tf.Session()
                self.sess = session
            else:
                session = self.sess
        session.run(tf.global_variables_initializer())
        # Pre-training stage: layer by layer
        for j in range(len(self.inner_layers)):
            current_layer = self.inner_layers[j]
            if summaries_dir is not None:
                layer_summaries_dir = '%s/pretrain_layer%d' % (summaries_dir, j)
                train_writer = tf.summary.FileWriter(layer_summaries_dir + '/train')
                test_writer = tf.summary.FileWriter(layer_summaries_dir + '/test')
                valid_writer = tf.summary.FileWriter(layer_summaries_dir + '/valid')
            # Get Stopping Criterion
            if pretrain_criterion == 'const_iterations':
                _pretrain_criterion = ConstIterations(num_iters=pretrain_iter_num)
                train_x = x
                train_y = y
            elif pretrain_criterion == 'monitor_based':
                num_samples = x.shape[0]
                valid_set_len = int(1 / 5 * num_samples)
                valid_x = x[num_samples - valid_set_len:num_samples, :]
                valid_y = y[num_samples - valid_set_len:num_samples, :]
                train_x = x[0:num_samples - valid_set_len, :]
                train_y = y[0:num_samples - valid_set_len, :]
                _pretrain_criterion = MonitorBased(n_steps=pretrain_iter_num,
                                                   monitor_fn=self.get_encode_loss,
                                                   monitor_fn_args=(current_layer, valid_x, valid_y),
                                                   save_fn=tf.train.Saver().save,
                                                   save_fn_args=(session, layer_summaries_dir + '/best.ckpt'))
            else:
                logger.error('Wrong criterion %s specified.' % pretrain_criterion)
                return
            injector = BatchInjector(data_x=train_x, data_y=train_y, batch_size=batch_size)
            i = 0
            while _pretrain_criterion.continue_learning():

                batch_x, batch_y = injector.next_batch()
                if summaries_dir is not None and (i % summary_interval == 0):
                    summary, loss = session.run(
                        [current_layer.merged, current_layer.encode_loss],
                        feed_dict={self.x: x, self.y_: y}
                    )
                    train_writer.add_summary(summary, i)
                    logger.info('Pre-training Layer %d, Step %d, training loss %g' % (j, i, loss))
                    if test_x is not None and test_y is not None:
                        summary, loss = session.run(
                            [current_layer.merged, current_layer.encode_loss],
                            feed_dict={self.x: test_x, self.y_: test_y}
                        )
                        test_writer.add_summary(summary, i)
                        logger.info('Pre-training Layer %d, Step %d, test loss %g' % (j, i, loss))
                    if pretrain_criterion == 'monitor_based':
                        summary, loss = session.run(
                            [current_layer.merged, current_layer.encode_loss],
                            feed_dict={self.x: valid_x, self.y_: valid_y}
                        )
                        valid_writer.add_summary(summary, i)
                        logger.info('Pre-training Layer %d, Step %d, valid loss %g' % (j, i, loss))
                _ = session.run(self.encode_opts[j], feed_dict={self.x: batch_x, self.y_: batch_y})
                i += 1
            if pretrain_criterion == 'monitor_based':
                tf.train.Saver().restore(session, layer_summaries_dir + '/best.ckpt')
            if summaries_dir is not None:
                train_writer.close()
                test_writer.close()
                valid_writer.close()
        # Finish all internal layer-by-layer pre-training
        # Start fine tuning
        if summaries_dir is not None:
            tuning_summaries_dir = '%s/fine_tuning' % summaries_dir
            train_writer = tf.summary.FileWriter(tuning_summaries_dir + '/train')
            test_writer = tf.summary.FileWriter(tuning_summaries_dir + '/test')
            valid_writer = tf.summary.FileWriter(tuning_summaries_dir + '/valid')
        # Setup Stopping Criterion
        if tuning_criterion == 'const_iterations':
            _tuning_criterion = ConstIterations(num_iters=pretrain_iter_num)
            train_x = x
            train_y = y
        elif tuning_criterion == 'monitor_based':
            num_samples = x.shape[0]
            valid_set_len = int(1 / 5 * num_samples)
            valid_x = x[num_samples - valid_set_len:num_samples, :]
            valid_y = y[num_samples - valid_set_len:num_samples, :]
            train_x = x[0:num_samples - valid_set_len, :]
            train_y = y[0:num_samples - valid_set_len, :]
            _tuning_criterion = MonitorBased(n_steps=pretrain_iter_num,
                                             monitor_fn=self.predict_accuracy,
                                             monitor_fn_args=(valid_x, valid_y),
                                             save_fn=tf.train.Saver().save,
                                             save_fn_args=(session, tuning_summaries_dir + '/best.ckpt'))
        else:
            logger.error('Wrong criterion %s specified.' % pretrain_criterion)
            return
        injector = BatchInjector(data_x=train_x, data_y=train_y, batch_size=batch_size)
        i = 0
        while _tuning_criterion.continue_learning():

            batch_x, batch_y = injector.next_batch()
            if summaries_dir is not None and (i % summary_interval == 0):
                summary, loss, accuracy = session.run([self.merged, self.loss, self.accuracy],
                                                      feed_dict={self.x: train_x, self.y_: train_y})
                train_writer.add_summary(summary, i)
                logger.info('Fine-Tuning: Step %d, training accuracy %g, loss %g' % (i, accuracy, loss))
                if (test_x is not None) and (test_y is not None):
                    merged, accuracy = session.run([self.merged, self.accuracy],
                                                   feed_dict={self.x: test_x, self.y_: test_y})
                    test_writer.add_summary(merged, i)
                    logger.info('Fine-Tuning: Step %d, test accuracy %g' % (i, accuracy))
                if tuning_criterion == 'monitor_based':
                    merged, accuracy = session.run([self.merged, self.accuracy],
                                                   feed_dict={self.x: valid_x, self.y_: valid_y})
                    valid_writer.add_summary(merged, i)
                    logger.info('Fine-Tuning: Step %d, valid accuracy %g' % (i, accuracy))
            _ = session.run(self.fine_tuning, feed_dict={self.x: batch_x, self.y_: batch_y})
            i += 1
        if tuning_criterion == 'monitor_based':
            tf.train.Saver().restore(session, tuning_summaries_dir + '/best.ckpt')
        if summaries_dir is not None:
            train_writer.close()
            test_writer.close()
            valid_writer.close()

    def get_encode_loss(self, layer, x, y, session=None):
        """Get encoder loss of layer specified
        """
        if session is None:
            if self.sess is None:
                session = tf.Session()
                self.sess = session
            else:
                session = self.sess
        return session.run(layer.encode_loss, feed_dict={self.x: x, self.y_: y})

    def predict_accuracy(self, x, y, session=None):
        """Get Accuracy given feature array and corresponding labels
        """
        if session is None:
            if self.sess is None:
                session = tf.Session()
                self.sess = session
            else:
                session = self.sess
        return session.run(self.accuracy, feed_dict={self.x: x, self.y_: y})

    def predict_proba(self, x, session=None):
        """Predict probability (Softmax)
        """
        if session is None:
            if self.sess is None:
                session = tf.Session()
                self.sess = session
            else:
                session = self.sess
        return session.run(self.y, feed_dict={self.x: x})

    def predict(self, x, session=None):
        if session is None:
            if self.sess is None:
                session = tf.Session()
                self.sess = session
            else:
                session = self.sess
        return session.run(self.y_class, feed_dict={self.x: x})


1		import logging
2		import numpy as np
3		import tensorflow as tf
4		from .layers import AutoencoderLayer, HiddenLayer, SoftmaxLayer
5		from .injectors import BatchInjector
6		from .criterion import MonitorBased, ConstIterations
7
8		logger = logging.getLogger(__name__)
9
10
11		class SDA:
12		"""Stacked Auto-encoder
13
14		Args:
15		num_features (:obj:`int`): Number of features.
16		num_classes (:obj:`int`): Number of classes.
17		layers (:obj:`list` of :obj:`int`): Series of hidden auto-encoder layers.
18		encode_optimizer: Optimizer used for auto-encoding process.
19		tuning_optimizer: Optimizer used for fine tuning.
20
21		Attributes:
22		num_features (:obj:`int`): Number of features.
23		num_classes (:obj:`int`): Number of classes.
24		x (:obj:`tensorflow.placeholder`): Input placeholder.
25		y_ (:obj:`tensorflow.placeholder`): Output placeholder.
26		inner_layers (:obj:`list`): List of auto-encoder hidden layers.
27
28		"""
29		def __init__(self, num_features, num_classes, layers, encode_optimizer=None, tuning_optimizer=None):
30		self.num_features = num_features
31		self.num_classes = num_classes
32		with tf.name_scope('input'):
33		self.x = tf.placeholder(tf.float32, shape=[None, num_features], name='input_x')
34		self.y_ = tf.placeholder(tf.float32, shape=[None, num_classes], name='input_y')
35		self.inner_layers = []
36		self.summaries = []
37		self.encode_opts = []
38		if encode_optimizer is None:
39		self.encode_optimizer = tf.train.AdamOptimizer()
40		else:
41		self.encode_optimizer = encode_optimizer
42		if tuning_optimizer is None:
43		self.tuning_optimizer = tf.train.AdamOptimizer()
44		else:
45		self.tuning_optimizer = tuning_optimizer
46		# Create Layers
47		for i in range(len(layers)):
48	View Code Duplication	if i == 0:
		0 ignored issues – show Duplication introduced 2017-01-23 16:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
49		# First Layer
50		self.inner_layers.append(
51		AutoencoderLayer(num_features, layers[i], x=self.x, name=('Hidden%d' % i))
52		)
53		else:
54		# inner Layer
55		self.inner_layers.append(
56		AutoencoderLayer(layers[i-1], layers[i], x=self.inner_layers[i-1].y, name=('Hidden%d' % i))
57		)
58		self.summaries += self.inner_layers[i].summaries
59		self.encode_opts.append(
60		self.encode_optimizer.minimize(self.inner_layers[i].encode_loss,
61		var_list=self.inner_layers[i].variables)
62		)
63	View Code Duplication	if num_classes == 1:
		0 ignored issues – show Duplication introduced 2017-01-23 16:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
64		# Output Layers
65		self.output_layer = HiddenLayer(layers[len(layers) - 1], num_classes, x=self.inner_layers[len(layers)-1].y,
66		name='Output', activation_fn=tf.sigmoid)
67		# Predicted Probability
68		self.y = self.output_layer.y
69		self.y_class = tf.cast(tf.greater_equal(self.y, 0.5), tf.float32)
70		# Loss
71		self.loss = tf.reduce_mean(
72		tf.nn.sigmoid_cross_entropy_with_logits(self.output_layer.logits, self.y_,
73		name='SigmoidCrossEntropyLoss')
74		)
75		self.correct_prediction = tf.equal(self.y_class, self.y_)
76		self.accuracy = tf.reduce_mean(tf.cast(self.correct_prediction, tf.float32))
77		else:
78		# Output Layers
79		self.output_layer = SoftmaxLayer(layers[len(layers) - 1], num_classes, x=self.inner_layers[len(layers)-1].y,
80		name='OutputLayer')
81		# Predicted Probability
82		self.y = self.output_layer.y
83		self.y_class = tf.argmax(self.y, 1)
84		# Loss
85		self.loss = tf.reduce_mean(
86		tf.nn.softmax_cross_entropy_with_logits(logits=self.output_layer.logits, labels=self.y_,
87		name='SoftmaxCrossEntropyLoss')
88		)
89		self.correct_prediction = tf.equal(self.y_class, tf.argmax(self.y_, 1))
90		self.accuracy = tf.reduce_mean(tf.cast(self.correct_prediction, tf.float32))
91		self.summaries.append(tf.summary.scalar('cross_entropy', self.loss))
92		self.summaries.append(tf.summary.scalar('accuracy', self.accuracy))
93		self.summaries += self.output_layer.summaries
94		with tf.name_scope('train'):
95		self.fine_tuning = self.tuning_optimizer.minimize(self.loss)
96		self.merged = tf.summary.merge(self.summaries)
97		self.sess = None
98
99		def fit(self, x, y, batch_size=100,
100		pretrain_iter_num=100, pretrain_criterion='const_iterations',
101		tuning_iter_num=100, tuning_criterion='const_iterations',
102		summaries_dir=None, test_x=None, test_y=None, summary_interval=10,
103		session=None):
104		"""Fit the model to the dataset
105
106		Args:
107		x (:obj:`numpy.ndarray`): Input features of shape (num_samples, num_features).
108		y (:obj:`numpy.ndarray`): Corresponding Labels of shape (num_samples) for binary classification,
109		or (num_samples, num_classes) for multi-class classification.
110		batch_size (:obj:`int`): Batch size used in gradient descent.
111		pretrain_iter_num (:obj:`int`): Number of const iterations or search depth for monitor based stopping
112		criterion in pre-training stage
113		pretrain_criterion (:obj:`str`): Stopping criteria in pre-training stage ('const_iterations' or
114		'monitor_based')
115		tuning_iter_num (:obj:`int`): Number of const iterations or search depth for monitor based stopping
116		criterion in fine-tuning stage
117		tuning_criterion (:obj:`str`): Stopping criteria in fine-tuning stage ('const_iterations' or
118		'monitor_based')
119		summaries_dir (:obj:`str`): Path of the directory to store summaries and saved values.
120		summary_interval (:obj:`int`): The step interval to export variable summaries.
121		test_x (:obj:`numpy.ndarray`): Test feature array used for monitoring training progress.
122		test_y (:obj:`numpy.ndarray): Test label array used for monitoring training progress.
123		session (:obj:`tensorflow.Session`): Session to run training functions.
124		"""
125		if session is None:
126		if self.sess is None:
127		session = tf.Session()
128		self.sess = session
129		else:
130		session = self.sess
131		session.run(tf.global_variables_initializer())
132		# Pre-training stage: layer by layer
133		for j in range(len(self.inner_layers)):
134		current_layer = self.inner_layers[j]
135		if summaries_dir is not None:
136		layer_summaries_dir = '%s/pretrain_layer%d' % (summaries_dir, j)
137		train_writer = tf.summary.FileWriter(layer_summaries_dir + '/train')
138		test_writer = tf.summary.FileWriter(layer_summaries_dir + '/test')
139		valid_writer = tf.summary.FileWriter(layer_summaries_dir + '/valid')
140		# Get Stopping Criterion
141		if pretrain_criterion == 'const_iterations':
142		_pretrain_criterion = ConstIterations(num_iters=pretrain_iter_num)
143		train_x = x
144		train_y = y
145		elif pretrain_criterion == 'monitor_based':
146		num_samples = x.shape[0]
147		valid_set_len = int(1 / 5 * num_samples)
148		valid_x = x[num_samples - valid_set_len:num_samples, :]
149		valid_y = y[num_samples - valid_set_len:num_samples, :]
150		train_x = x[0:num_samples - valid_set_len, :]
151		train_y = y[0:num_samples - valid_set_len, :]
152		_pretrain_criterion = MonitorBased(n_steps=pretrain_iter_num,
153		monitor_fn=self.get_encode_loss,
154		monitor_fn_args=(current_layer, valid_x, valid_y),
155		save_fn=tf.train.Saver().save,
156		save_fn_args=(session, layer_summaries_dir + '/best.ckpt'))
157		else:
158		logger.error('Wrong criterion %s specified.' % pretrain_criterion)
159		return
160		injector = BatchInjector(data_x=train_x, data_y=train_y, batch_size=batch_size)
161		i = 0
162	View Code Duplication	while _pretrain_criterion.continue_learning():
		0 ignored issues – show Duplication introduced 2017-01-23 16:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
163		batch_x, batch_y = injector.next_batch()
164		if summaries_dir is not None and (i % summary_interval == 0):
165		summary, loss = session.run(
166		[current_layer.merged, current_layer.encode_loss],
167		feed_dict={self.x: x, self.y_: y}
168		)
169		train_writer.add_summary(summary, i)
170		logger.info('Pre-training Layer %d, Step %d, training loss %g' % (j, i, loss))
171		if test_x is not None and test_y is not None:
172		summary, loss = session.run(
173		[current_layer.merged, current_layer.encode_loss],
174		feed_dict={self.x: test_x, self.y_: test_y}
175		)
176		test_writer.add_summary(summary, i)
177		logger.info('Pre-training Layer %d, Step %d, test loss %g' % (j, i, loss))
178		if pretrain_criterion == 'monitor_based':
179		summary, loss = session.run(
180		[current_layer.merged, current_layer.encode_loss],
181		feed_dict={self.x: valid_x, self.y_: valid_y}
182		)
183		valid_writer.add_summary(summary, i)
184		logger.info('Pre-training Layer %d, Step %d, valid loss %g' % (j, i, loss))
185		_ = session.run(self.encode_opts[j], feed_dict={self.x: batch_x, self.y_: batch_y})
186		i += 1
187		if pretrain_criterion == 'monitor_based':
188		tf.train.Saver().restore(session, layer_summaries_dir + '/best.ckpt')
189		if summaries_dir is not None:
190		train_writer.close()
191		test_writer.close()
192		valid_writer.close()
193		# Finish all internal layer-by-layer pre-training
194		# Start fine tuning
195		if summaries_dir is not None:
196		tuning_summaries_dir = '%s/fine_tuning' % summaries_dir
197		train_writer = tf.summary.FileWriter(tuning_summaries_dir + '/train')
198		test_writer = tf.summary.FileWriter(tuning_summaries_dir + '/test')
199		valid_writer = tf.summary.FileWriter(tuning_summaries_dir + '/valid')
200		# Setup Stopping Criterion
201		if tuning_criterion == 'const_iterations':
202		_tuning_criterion = ConstIterations(num_iters=pretrain_iter_num)
203		train_x = x
204		train_y = y
205		elif tuning_criterion == 'monitor_based':
206		num_samples = x.shape[0]
207		valid_set_len = int(1 / 5 * num_samples)
208		valid_x = x[num_samples - valid_set_len:num_samples, :]
209		valid_y = y[num_samples - valid_set_len:num_samples, :]
210		train_x = x[0:num_samples - valid_set_len, :]
211		train_y = y[0:num_samples - valid_set_len, :]
212		_tuning_criterion = MonitorBased(n_steps=pretrain_iter_num,
213		monitor_fn=self.predict_accuracy,
214		monitor_fn_args=(valid_x, valid_y),
215		save_fn=tf.train.Saver().save,
216		save_fn_args=(session, tuning_summaries_dir + '/best.ckpt'))
217		else:
218		logger.error('Wrong criterion %s specified.' % pretrain_criterion)
219		return
220		injector = BatchInjector(data_x=train_x, data_y=train_y, batch_size=batch_size)
221		i = 0
222	View Code Duplication	while _tuning_criterion.continue_learning():
		0 ignored issues – show Duplication introduced 2017-01-23 16:44 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
223		batch_x, batch_y = injector.next_batch()
224		if summaries_dir is not None and (i % summary_interval == 0):
225		summary, loss, accuracy = session.run([self.merged, self.loss, self.accuracy],
226		feed_dict={self.x: train_x, self.y_: train_y})
227		train_writer.add_summary(summary, i)
228		logger.info('Fine-Tuning: Step %d, training accuracy %g, loss %g' % (i, accuracy, loss))
229		if (test_x is not None) and (test_y is not None):
230		merged, accuracy = session.run([self.merged, self.accuracy],
231		feed_dict={self.x: test_x, self.y_: test_y})
232		test_writer.add_summary(merged, i)
233		logger.info('Fine-Tuning: Step %d, test accuracy %g' % (i, accuracy))
234		if tuning_criterion == 'monitor_based':
235		merged, accuracy = session.run([self.merged, self.accuracy],
236		feed_dict={self.x: valid_x, self.y_: valid_y})
237		valid_writer.add_summary(merged, i)
238		logger.info('Fine-Tuning: Step %d, valid accuracy %g' % (i, accuracy))
239		_ = session.run(self.fine_tuning, feed_dict={self.x: batch_x, self.y_: batch_y})
240		i += 1
241		if tuning_criterion == 'monitor_based':
242		tf.train.Saver().restore(session, tuning_summaries_dir + '/best.ckpt')
243		if summaries_dir is not None:
244		train_writer.close()
245		test_writer.close()
246		valid_writer.close()
247
248		def get_encode_loss(self, layer, x, y, session=None):
249		"""Get encoder loss of layer specified
250		"""
251		if session is None:
252		if self.sess is None:
253		session = tf.Session()
254		self.sess = session
255		else:
256		session = self.sess
257		return session.run(layer.encode_loss, feed_dict={self.x: x, self.y_: y})
258
259		def predict_accuracy(self, x, y, session=None):
260		"""Get Accuracy given feature array and corresponding labels
261		"""
262		if session is None:
263		if self.sess is None:
264		session = tf.Session()
265		self.sess = session
266		else:
267		session = self.sess
268		return session.run(self.accuracy, feed_dict={self.x: x, self.y_: y})
269
270		def predict_proba(self, x, session=None):
271		"""Predict probability (Softmax)
272		"""
273		if session is None:
274		if self.sess is None:
275		session = tf.Session()
276		self.sess = session
277		else:
278		session = self.sess
279		return session.run(self.y, feed_dict={self.x: x})
280
281		def predict(self, x, session=None):
282		if session is None:
283		if self.sess is None:
284		session = tf.Session()
285		self.sess = session
286		else:
287		session = self.sess
288		return session.run(self.y_class, feed_dict={self.x: x})
289

TinghuiWang / pyActLearn

SDA.predict() A last analyzed 2018-03-13 15:38 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SDA.predict() A
last analyzed 2018-03-13 15:38 UTC