kNN_accuracy() - Code Metrics - Inspection of "version number set only on one location" - NLeSC/mcfly - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fc3729...81cbcf )

by Christiaan

created 2016-10-05 14:21 UTC

kNN_accuracy() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
dl	0
loc	35
ccs	0
cts	7
cp	0
crap	2
rs	8.8571

"""
 Summary:
 Function generate_models from modelgen.py generates and compiles models
 Function train_models_on_samples trains those models
 Function plotTrainingProcess plots the training process
 Function find_best_architecture is wrapper function that combines
 these steps
 Example function calls in 'EvaluateDifferentModels.ipynb'
"""
import numpy as np
from matplotlib import pyplot as plt
from . import modelgen
from sklearn import neighbors, metrics
import warnings
import json
import os


def train_models_on_samples(X_train, y_train, X_val, y_val, models,

                            nr_epochs=5, subset_size=100, verbose=True,
                            outputfile=None):
    """
    Given a list of compiled models, this function trains
    them all on a subset of the train data. If the given size of the subset is
    smaller then the size of the data, the complete data set is used.

    Parameters
    ----------
    X_train : numpy array of shape (num_samples, num_timesteps, num_channels)
        The input dataset for training
    y_train : numpy array of shape (num_samples, num_classes)
        The output classes for the train data, in binary format
    X_val : numpy array of shape (num_samples_val, num_timesteps, num_channels)
        The input dataset for validation
    y_val : numpy array of shape (num_samples_val, num_classes)
        The output classes for the validation data, in binary format
    models : list of model, params, modeltypes
        List of keras models to train
    nr_epochs : int, optional
        nr of epochs to use for training one model
    subset_size :
        The number of samples used from the complete train set
    verbose : bool, optional
        flag for displaying verbose output
    outputfile : str, optional
        File location to store the model results

    Returns
    ----------
    histories : list of Keras History objects
        train histories for all models
    val_accuracies : list of floats
        validation accuraracies of the models
    val_losses : list of floats
        validation losses of the models
    """
    # if subset_size is smaller then X_train, this will work fine
    X_train_sub = X_train[:subset_size,:,:]

    y_train_sub = y_train[:subset_size,:]


    histories = []
    val_accuracies = []
    val_losses = []
    for i, (model, params, model_types) in enumerate(models):
        if verbose:
            print('Training model %d'%i, model_types)
        history = model.fit(X_train_sub, y_train_sub,
                            nb_epoch=nr_epochs, batch_size=20,
                            # see comment on subsize_set
                            validation_data=(X_val, y_val),
                            verbose=verbose)
        histories.append(history)
        val_accuracies.append(history.history['val_acc'][-1])
        val_losses.append(history.history['val_loss'][-1])
        if outputfile is not None:
            storetrainhist2json(params, model_types,
                                history.history, outputfile)
    return histories, val_accuracies, val_losses


def storetrainhist2json(params, model_type, history, outputfile):
    """
    This function stores the model parameters, the loss and accuracy history
    of one model in a JSON file. It appends the model information to the
    existing models in the file.

    Parameters
    ----------
    params : dict
        parameters for one model
    model_type : Keras model object
        Keras model object for one model
    history : dict
        training history from one model
    outputfile : str
        path where the json file needs to be stored
    """
    jsondata = params.copy()
    for k in jsondata.keys():
        if isinstance(jsondata[k], np.ndarray):
            jsondata[k] = jsondata[k].tolist()
    jsondata['train_acc'] = history['acc']
    jsondata['train_loss'] = history['loss']
    jsondata['val_acc'] = history['val_acc']
    jsondata['val_loss'] = history['val_loss']
    jsondata['modeltype'] = model_type
    jsondata['modeltype'] = model_type
    if os.path.isfile(outputfile):
        with open(outputfile, 'r') as outfile:
            previousdata = json.load(outfile)
    else:
        previousdata = []
    previousdata.append(jsondata)
    with open(outputfile, 'w') as outfile:
        json.dump(previousdata, outfile, sort_keys = True,

                  indent = 4, ensure_ascii=False)



def plotTrainingProcess(history, name='Model', ax=None):

    """
    This function plots the loss and accuracy on the train and validation set,
    for each epoch in the history of one model.

    Parameters
    ----------
    history : keras History object
        The history object of the training process corresponding to one model
    name : str
        Name of the model, to display in the title
    ax : Axis, optional
        Specific axis to plot on

    """
    if ax is None:
        fig, ax = plt.subplots()
    ax2 = ax.twinx()
    LN = len(history.history['val_loss'])

    val_loss, = ax.plot(range(LN), history.history['val_loss'], 'g--',
                        label='validation loss')
    train_loss, = ax.plot(range(LN), history.history['loss'], 'g-',
                          label='train loss')
    val_acc, = ax2.plot(range(LN), history.history['val_acc'], 'b--',
                        label='validation accuracy')
    train_acc, = ax2.plot(range(LN), history.history['acc'], 'b-',
                          label='train accuracy')
    ax.set_xlabel('epoch')
    ax.set_ylabel('loss', color='g')
    ax2.set_ylabel('accuracy', color='b')
    plt.legend(handles=[val_loss, train_loss, val_acc, train_acc],
               loc=2, bbox_to_anchor=(1.1, 1))
    plt.title(name)


def find_best_architecture(X_train, y_train, X_val, y_val, verbose=True,

                           number_of_models=5, nr_epochs=5, subset_size=100,
                           outputpath=None, **kwargs
                           ):
    """
    Tries out a number of models on a subsample of the data,
    and outputs the best found architecture and hyperparameters.

    Parameters
    ----------
    X_train : numpy array of shape (num_samples, num_timesteps, num_channels)
        The input dataset for training
    y_train : numpy array of shape (num_samples, num_classes)
        The output classes for the train data, in binary format
    X_val : numpy array of shape (num_samples_val, num_timesteps, num_channels)
        The input dataset for validation
    y_val : numpy array of shape (num_samples_val, num_classes)
        The output classes for the validation data, in binary format
    verbose : bool, optional
        flag for displaying verbose output
    number_of_models : int
        The number of models to generate and test
    nr_epochs : int
        The number of epochs that each model is trained
    subset_size : int
        The size of the subset of the data that is used for finding
        the optimal architecture
    outputpath : str, optional
        File location to store the model results
    **kwargs: key-value parameters
        parameters for generating the models
        (see docstring for modelgen.generate_models)

    Returns
    ----------
    best_model : Keras model
        Best performing model, already trained on a small sample data set.
    best_params : dict
        Dictionary containing the hyperparameters for the best model
    best_model_type : str
        Type of the best model
    knn_acc : float
        accuaracy for kNN prediction on validation set
    """
    models = modelgen.generate_models(X_train.shape, y_train.shape[1],
                                      number_of_models=number_of_models,
                                      **kwargs)
    histories, val_accuracies, val_losses = train_models_on_samples(X_train,
                                                                    y_train,
                                                                    X_val,
                                                                    y_val,
                                                                    models,
                                                                    nr_epochs,
                                                                    subset_size=subset_size,

                                                                    verbose=verbose,

                                                                    outputfile=outputpath)

    best_model_index = np.argmax(val_accuracies)
    best_model, best_params, best_model_type = models[best_model_index]
    knn_acc = kNN_accuracy(
        X_train[:subset_size,:,:], y_train[:subset_size,:], X_val, y_val)

    if verbose:
        for i in range(len(models)):  # now one plot per model, ultimately we
            # may want all models in one plot to allow for direct comparison
            name = str(models[i][1])
            plotTrainingProcess(histories[i], name)
        print('Best model: model ', best_model_index)
        print('Model type: ', best_model_type)
        print('Hyperparameters: ', best_params)
        print('Accuracy on validation set: ', val_accuracies[best_model_index])
        print('Accuracy of kNN on validation set', knn_acc)

    if val_accuracies[best_model_index] < knn_acc:
        warnings.warn('Best model not better than kNN: ' +
                      str(val_accuracies[best_model_index]) + ' vs  ' +
                      str(knn_acc)
                      )
    return best_model, best_params, best_model_type, knn_acc


def kNN_accuracy(X_train, y_train, X_val, y_val, k=1):

    """
    Performs k-Neigherst Neighbors and returns the accuracy score.

    Parameters
    ----------
    X_train : numpy array
        Train set of shape (num_samples, num_timesteps, num_channels)
    y_train : numpy array
        Class labels for train set
    X_val : numpy array
        Validation set of shape (num_samples, num_timesteps, num_channels)
    y_val : numpy array
        Class labels for validation set
    k : int
        number of neighbors to use for classifying

    Returns
    -------
    accuracy: float
        accuracy score on the validation set
    """
    num_samples, num_timesteps, num_channels = X_train.shape
    clf = neighbors.KNeighborsClassifier(k)
    clf.fit(
        X_train.reshape(
            num_samples,
            num_timesteps *
            num_channels),
        y_train)
    num_samples, num_timesteps, num_channels = X_val.shape
    val_predict = clf.predict(
        X_val.reshape(num_samples,
                      num_timesteps * num_channels))
    return metrics.accuracy_score(val_predict, y_val)


1			"""
2			Summary:
3			Function generate_models from modelgen.py generates and compiles models
4			Function train_models_on_samples trains those models
5			Function plotTrainingProcess plots the training process
6			Function find_best_architecture is wrapper function that combines
7			these steps
8			Example function calls in 'EvaluateDifferentModels.ipynb'
9			"""
10			import numpy as np
11			from matplotlib import pyplot as plt
12			from . import modelgen
13			from sklearn import neighbors, metrics
14			import warnings
15			import json
16			import os
17
18
19			def train_models_on_samples(X_train, y_train, X_val, y_val, models,
			0 ignored issues – show Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `X_train` does not conform to the argument naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `X_val` does not conform to the argument naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
20			nr_epochs=5, subset_size=100, verbose=True,
21			outputfile=None):
22			"""
23			Given a list of compiled models, this function trains
24			them all on a subset of the train data. If the given size of the subset is
25			smaller then the size of the data, the complete data set is used.
26
27			Parameters
28			----------
29			X_train : numpy array of shape (num_samples, num_timesteps, num_channels)
30			The input dataset for training
31			y_train : numpy array of shape (num_samples, num_classes)
32			The output classes for the train data, in binary format
33			X_val : numpy array of shape (num_samples_val, num_timesteps, num_channels)
34			The input dataset for validation
35			y_val : numpy array of shape (num_samples_val, num_classes)
36			The output classes for the validation data, in binary format
37			models : list of model, params, modeltypes
38			List of keras models to train
39			nr_epochs : int, optional
40			nr of epochs to use for training one model
41			subset_size :
42			The number of samples used from the complete train set
43			verbose : bool, optional
44			flag for displaying verbose output
45			outputfile : str, optional
46			File location to store the model results
47
48			Returns
49			----------
50			histories : list of Keras History objects
51			train histories for all models
52			val_accuracies : list of floats
53			validation accuraracies of the models
54			val_losses : list of floats
55			validation losses of the models
56			"""
57			# if subset_size is smaller then X_train, this will work fine
58			X_train_sub = X_train[:subset_size,:,:]
			0 ignored issues – show Coding Style introduced 2016-08-15 08:04 UTC by Report Bug Copy Issue Report Exactly one space required after comma X_train_sub = X_train[:subset_size,:,:] ^ Loading history... Coding Style introduced 2016-08-15 08:04 UTC by Report Bug Copy Issue Report Exactly one space required after comma X_train_sub = X_train[:subset_size,:,:] ^ Loading history... Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `X_train_sub` does not conform to the variable naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
59			y_train_sub = y_train[:subset_size,:]
			0 ignored issues – show Coding Style introduced 2016-08-15 08:04 UTC by Report Bug Copy Issue Report Exactly one space required after comma y_train_sub = y_train[:subset_size,:] ^ Loading history...
60
61			histories = []
62			val_accuracies = []
63			val_losses = []
64			for i, (model, params, model_types) in enumerate(models):
65			if verbose:
66			print('Training model %d'%i, model_types)
67			history = model.fit(X_train_sub, y_train_sub,
68			nb_epoch=nr_epochs, batch_size=20,
69			# see comment on subsize_set
70			validation_data=(X_val, y_val),
71			verbose=verbose)
72			histories.append(history)
73			val_accuracies.append(history.history['val_acc'][-1])
74			val_losses.append(history.history['val_loss'][-1])
75			if outputfile is not None:
76			storetrainhist2json(params, model_types,
77			history.history, outputfile)
78			return histories, val_accuracies, val_losses
79
80
81			def storetrainhist2json(params, model_type, history, outputfile):
82			"""
83			This function stores the model parameters, the loss and accuracy history
84			of one model in a JSON file. It appends the model information to the
85			existing models in the file.
86
87			Parameters
88			----------
89			params : dict
90			parameters for one model
91			model_type : Keras model object
92			Keras model object for one model
93			history : dict
94			training history from one model
95			outputfile : str
96			path where the json file needs to be stored
97			"""
98			jsondata = params.copy()
99			for k in jsondata.keys():
100			if isinstance(jsondata[k], np.ndarray):
101			jsondata[k] = jsondata[k].tolist()
102			jsondata['train_acc'] = history['acc']
103			jsondata['train_loss'] = history['loss']
104			jsondata['val_acc'] = history['val_acc']
105			jsondata['val_loss'] = history['val_loss']
106			jsondata['modeltype'] = model_type
107			jsondata['modeltype'] = model_type
108			if os.path.isfile(outputfile):
109			with open(outputfile, 'r') as outfile:
110			previousdata = json.load(outfile)
111			else:
112			previousdata = []
113			previousdata.append(jsondata)
114			with open(outputfile, 'w') as outfile:
115			json.dump(previousdata, outfile, sort_keys = True,
			0 ignored issues – show Coding Style introduced 2016-08-26 15:43 UTC by Report Bug Copy Issue Report No space allowed around keyword argument assignment json.dump(previousdata, outfile, sort_keys = True, ^ Loading history...
116			indent = 4, ensure_ascii=False)
			0 ignored issues – show Coding Style introduced 2016-08-26 15:43 UTC by Report Bug Copy Issue Report No space allowed around keyword argument assignment indent = 4, ensure_ascii=False) ^ Loading history...
117
118
119			def plotTrainingProcess(history, name='Model', ax=None):
			0 ignored issues – show Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `plotTrainingProcess` does not conform to the function naming conventions (`[a-z_][a-z0-9_]{2,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
120			"""
121			This function plots the loss and accuracy on the train and validation set,
122			for each epoch in the history of one model.
123
124			Parameters
125			----------
126			history : keras History object
127			The history object of the training process corresponding to one model
128			name : str
129			Name of the model, to display in the title
130			ax : Axis, optional
131			Specific axis to plot on
132
133			"""
134			if ax is None:
135			fig, ax = plt.subplots()
136			ax2 = ax.twinx()
137			LN = len(history.history['val_loss'])
			0 ignored issues – show Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `LN` does not conform to the variable naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
138			val_loss, = ax.plot(range(LN), history.history['val_loss'], 'g--',
139			label='validation loss')
140			train_loss, = ax.plot(range(LN), history.history['loss'], 'g-',
141			label='train loss')
142			val_acc, = ax2.plot(range(LN), history.history['val_acc'], 'b--',
143			label='validation accuracy')
144			train_acc, = ax2.plot(range(LN), history.history['acc'], 'b-',
145			label='train accuracy')
146			ax.set_xlabel('epoch')
147			ax.set_ylabel('loss', color='g')
148			ax2.set_ylabel('accuracy', color='b')
149			plt.legend(handles=[val_loss, train_loss, val_acc, train_acc],
150			loc=2, bbox_to_anchor=(1.1, 1))
151			plt.title(name)
152
153
154			def find_best_architecture(X_train, y_train, X_val, y_val, verbose=True,
			0 ignored issues – show Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `X_train` does not conform to the argument naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `X_val` does not conform to the argument naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
155			number_of_models=5, nr_epochs=5, subset_size=100,
156			outputpath=None, **kwargs
157			):
158			"""
159			Tries out a number of models on a subsample of the data,
160			and outputs the best found architecture and hyperparameters.
161
162			Parameters
163			----------
164			X_train : numpy array of shape (num_samples, num_timesteps, num_channels)
165			The input dataset for training
166			y_train : numpy array of shape (num_samples, num_classes)
167			The output classes for the train data, in binary format
168			X_val : numpy array of shape (num_samples_val, num_timesteps, num_channels)
169			The input dataset for validation
170			y_val : numpy array of shape (num_samples_val, num_classes)
171			The output classes for the validation data, in binary format
172			verbose : bool, optional
173			flag for displaying verbose output
174			number_of_models : int
175			The number of models to generate and test
176			nr_epochs : int
177			The number of epochs that each model is trained
178			subset_size : int
179			The size of the subset of the data that is used for finding
180			the optimal architecture
181			outputpath : str, optional
182			File location to store the model results
183			**kwargs: key-value parameters
184			parameters for generating the models
185			(see docstring for modelgen.generate_models)
186
187			Returns
188			----------
189			best_model : Keras model
190			Best performing model, already trained on a small sample data set.
191			best_params : dict
192			Dictionary containing the hyperparameters for the best model
193			best_model_type : str
194			Type of the best model
195			knn_acc : float
196			accuaracy for kNN prediction on validation set
197			"""
198			models = modelgen.generate_models(X_train.shape, y_train.shape[1],
199			number_of_models=number_of_models,
200			**kwargs)
201			histories, val_accuracies, val_losses = train_models_on_samples(X_train,
202			y_train,
203			X_val,
204			y_val,
205			models,
206			nr_epochs,
207			subset_size=subset_size,
			0 ignored issues – show Coding Style introduced 2016-08-04 09:16 UTC by Report Bug Copy Issue Report This line is too long as per the coding-style (92/79). This check looks for lines that are too long. You can specify the maximum line length. Loading history...
208			verbose=verbose,
			0 ignored issues – show Coding Style introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report This line is too long as per the coding-style (84/79). This check looks for lines that are too long. You can specify the maximum line length. Loading history...
209			outputfile=outputpath)
			0 ignored issues – show Coding Style introduced 2016-08-09 14:55 UTC by Report Bug Copy Issue Report This line is too long as per the coding-style (90/79). This check looks for lines that are too long. You can specify the maximum line length. Loading history...
210			best_model_index = np.argmax(val_accuracies)
211			best_model, best_params, best_model_type = models[best_model_index]
212			knn_acc = kNN_accuracy(
213			X_train[:subset_size,:,:], y_train[:subset_size,:], X_val, y_val)
			0 ignored issues – show Coding Style introduced 2016-08-15 08:04 UTC by Report Bug Copy Issue Report Exactly one space required after comma X_train[:subset_size,:,:], y_train[:subset_size,:], X_val, y_val) ^ Loading history... Coding Style introduced 2016-08-15 08:04 UTC by Report Bug Copy Issue Report Exactly one space required after comma X_train[:subset_size,:,:], y_train[:subset_size,:], X_val, y_val) ^ Loading history... Coding Style introduced 2016-08-15 08:04 UTC by Report Bug Copy Issue Report Exactly one space required after comma X_train[:subset_size,:,:], y_train[:subset_size,:], X_val, y_val) ^ Loading history...
214			if verbose:
215			for i in range(len(models)): # now one plot per model, ultimately we
216			# may want all models in one plot to allow for direct comparison
217			name = str(models[i][1])
218			plotTrainingProcess(histories[i], name)
219			print('Best model: model ', best_model_index)
220			print('Model type: ', best_model_type)
221			print('Hyperparameters: ', best_params)
222			print('Accuracy on validation set: ', val_accuracies[best_model_index])
223			print('Accuracy of kNN on validation set', knn_acc)
224
225			if val_accuracies[best_model_index] < knn_acc:
226			warnings.warn('Best model not better than kNN: ' +
227			str(val_accuracies[best_model_index]) + ' vs ' +
228			str(knn_acc)
229			)
230			return best_model, best_params, best_model_type, knn_acc
231
232
233			def kNN_accuracy(X_train, y_train, X_val, y_val, k=1):
			0 ignored issues – show Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `kNN_accuracy` does not conform to the function naming conventions (`[a-z_][a-z0-9_]{2,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `X_train` does not conform to the argument naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... Coding Style Naming introduced 2016-07-07 14:47 UTC by Report Bug Copy Issue Report The name `X_val` does not conform to the argument naming conventions (`[a-z_][a-z0-9_]{1,30}$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
234			"""
235			Performs k-Neigherst Neighbors and returns the accuracy score.
236
237			Parameters
238			----------
239			X_train : numpy array
240			Train set of shape (num_samples, num_timesteps, num_channels)
241			y_train : numpy array
242			Class labels for train set
243			X_val : numpy array
244			Validation set of shape (num_samples, num_timesteps, num_channels)
245			y_val : numpy array
246			Class labels for validation set
247			k : int
248			number of neighbors to use for classifying
249
250			Returns
251			-------
252			accuracy: float
253			accuracy score on the validation set
254			"""
255			num_samples, num_timesteps, num_channels = X_train.shape
256			clf = neighbors.KNeighborsClassifier(k)
257			clf.fit(
258			X_train.reshape(
259			num_samples,
260			num_timesteps *
261			num_channels),
262			y_train)
263			num_samples, num_timesteps, num_channels = X_val.shape
264			val_predict = clf.predict(
265			X_val.reshape(num_samples,
266			num_timesteps * num_channels))
267			return metrics.accuracy_score(val_predict, y_val)
268

NLeSC / mcfly

Push — master ( fc3729...81cbcf )

kNN_accuracy() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like