Python numpy 模块,__name__() 实例源码

我们从Python开源项目中,提取了以下50个代码示例,用于说明如何使用numpy.__name__()

项目:keras    作者:GeekLiB    | 项目源码 | 文件源码
def create_input_layer(self, batch_input_shape,
                           input_dtype=None, name=None):
        if not name:
            prefix = self.__class__.__name__.lower() + '_input_'
            name = prefix + str(K.get_uid(prefix))
        if not input_dtype:
            input_dtype = K.floatx()

        self.batch_input_shape = batch_input_shape
        self.input_dtype = input_dtype

        # Instantiate the input layer.
        x = Input(batch_shape=batch_input_shape,
                  dtype=input_dtype, name=name)
        # This will build the current layer
        # and create the node connecting the current layer
        # to the input layer we just created.
        self(x)
项目:keras    作者:GeekLiB    | 项目源码 | 文件源码
def to_json(self, **kwargs):
        '''Returns a JSON string containing the network configuration.

        To load a network from a JSON save file, use
        `keras.models.model_from_json(json_string, custom_objects={})`.
        '''
        import json

        def get_json_type(obj):
            # If obj is any numpy type
            if type(obj).__module__ == np.__name__:
                return obj.item()

            # If obj is a python 'type'
            if type(obj).__name__ == type.__name__:
                return obj.__name__

            raise TypeError('Not JSON Serializable:', obj)

        model_config = self._updated_config()
        return json.dumps(model_config, default=get_json_type, **kwargs)
项目:keras    作者:GeekLiB    | 项目源码 | 文件源码
def get_config(self):
        '''Returns the model configuration
        as a Python list.
        '''
        config = []
        if isinstance(self.layers[0], Merge):
            assert hasattr(self.layers[0], 'layers')
            layers = []
            for layer in self.layers[0].layers:
                layer_config = {'class_name': layer.__class__.__name__,
                                'config': layer.get_config()}
                layers.append(layer_config)
            merge_config = self.layers[0].get_config()
            merge_config['layers'] = layers
            config.append({'class_name': 'Merge', 'config': merge_config})
        else:
            config.append({'class_name': self.layers[0].__class__.__name__,
                           'config': self.layers[0].get_config()})
        for layer in self.layers[1:]:
            config.append({'class_name': layer.__class__.__name__,
                           'config': layer.get_config()})
        return copy.deepcopy(config)
项目:supvisors    作者:julien6387    | 项目源码 | 文件源码
def test_linear_regression_numpy(self):
        """ Test the linear regression using numpy (if installed). """
        # test that numpy is installed
        try:
            import numpy
            numpy.__name__
        except ImportError:
            raise unittest.SkipTest('cannot test as optional numpy is not installed')
        # perform the test with numpy
        from supvisors.utils import get_linear_regression, get_simple_linear_regression
        xdata = [2, 4, 6, 8, 10, 12]
        ydata = [3, 4, 5, 6, 7, 8]
        # test linear regression
        a, b = get_linear_regression(xdata, ydata)
        self.assertAlmostEqual(0.5, a)
        self.assertAlmostEqual(2.0, b)
        # test simple linear regression
        a, b = get_simple_linear_regression(ydata)
        self.assertAlmostEqual(1.0, a)
        self.assertAlmostEqual(3.0, b)
项目:deep-learning-keras-projects    作者:jasmeetsb    | 项目源码 | 文件源码
def create_input_layer(self, batch_input_shape,
                           input_dtype=None, name=None):
        if not name:
            prefix = self.__class__.__name__.lower() + '_input_'
            name = prefix + str(K.get_uid(prefix))
        if not input_dtype:
            input_dtype = K.floatx()

        self.batch_input_shape = batch_input_shape
        self.input_dtype = input_dtype

        # Instantiate the input layer.
        x = Input(batch_shape=batch_input_shape,
                  dtype=input_dtype, name=name)
        # This will build the current layer
        # and create the node connecting the current layer
        # to the input layer we just created.
        self(x)
项目:deep-learning-keras-projects    作者:jasmeetsb    | 项目源码 | 文件源码
def to_json(self, **kwargs):
        """Returns a JSON string containing the network configuration.

        To load a network from a JSON save file, use
        `keras.models.model_from_json(json_string, custom_objects={})`.
        """
        import json

        def get_json_type(obj):
            # If obj is any numpy type
            if type(obj).__module__ == np.__name__:
                return obj.item()

            # If obj is a python 'type'
            if type(obj).__name__ == type.__name__:
                return obj.__name__

            raise TypeError('Not JSON Serializable:', obj)

        model_config = self._updated_config()
        return json.dumps(model_config, default=get_json_type, **kwargs)
项目:deep-learning-keras-projects    作者:jasmeetsb    | 项目源码 | 文件源码
def get_config(self):
        """Returns the model configuration
        as a Python list.
        """
        config = []
        if isinstance(self.layers[0], Merge):
            assert hasattr(self.layers[0], 'layers')
            layers = []
            for layer in self.layers[0].layers:
                layer_config = {'class_name': layer.__class__.__name__,
                                'config': layer.get_config()}
                layers.append(layer_config)
            merge_config = self.layers[0].get_config()
            merge_config['layers'] = layers
            config.append({'class_name': 'Merge', 'config': merge_config})
        else:
            config.append({'class_name': self.layers[0].__class__.__name__,
                           'config': self.layers[0].get_config()})
        for layer in self.layers[1:]:
            config.append({'class_name': layer.__class__.__name__,
                           'config': layer.get_config()})
        return copy.deepcopy(config)
项目:tfnn    作者:MorvanZhou    | 项目源码 | 文件源码
def __init__(self, xs, ys, name=None):
        """
        Input data sets.
        :param xs: data, shape(n_samples, n_xs), accept numpy, pandas, list
        :param ys: labels, shape(n_samples, n_ys), accept numpy, pandas, list
        """
        if (type(xs).__module__ == np.__name__) & (type(ys).__module__ == np.__name__):
            self.module = 'numpy_data'
        elif ('pandas' in type(xs).__module__) & ('pandas' in type(ys).__module__):
            xs, ys = np.asarray(xs), np.asarray(ys)
        elif (type(xs) == list) & (type(ys) == list):
            xs, ys = np.asarray(xs), np.asarray(ys)
        else:
            raise TypeError('all data type must be numpy or pandas')
        if ys.ndim < 2:
            ys = ys[:, np.newaxis]
        if xs.ndim < 2:
            xs = xs[:, np.newaxis]

        self.n_xfeatures = xs.shape[-1]     # col for 2 dims, channel for 3 dims
        self.n_yfeatures = ys.shape[-1]     # col for 2 dims,
        self.data = np.hstack((xs, ys))
        self.n_samples = ys.shape[0]
        self.name = name
项目:SPHERE-HyperStream    作者:IRC-SPHERE    | 项目源码 | 文件源码
def serialise_dict(dd):
    out = {}

    for kk, vv in dd.iteritems():
        if isinstance(vv, type):
            continue

        try:
            if vv is None:
                out[kk] = None

            elif type(vv).__module__ == numpy_name:
                out[kk] = vv.tolist()

            elif isinstance(vv, dict):
                out[kk] = serialise_dict(vv)

            elif isinstance(vv, (str, list, bool, int, float)):
                out[kk] = vv

        except Exception as ex:
            raise ex

    return out
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def get(identifier):
      if identifier is None:
        return linear
      if isinstance(identifier, six.string_types):
        identifier = str(identifier)
        return deserialize(identifier)
      elif callable(identifier):
        if isinstance(identifier, Layer):
          logging.warning(
              'Do not pass a layer instance (such as {identifier}) as the '
              'activation argument of another layer. Instead, advanced '
              'activation layers should be used just like any other '
              'layer in a model.'.format(identifier=identifier.__class__.__name__))
        return identifier
      else:
        raise ValueError('Could not interpret '
                         'activation function identifier:', identifier)

## backend.py
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def count_params(self):
            """Count the total number of scalars composing the weights.

            Returns:
                An integer count.

            Raises:
                RuntimeError: if the layer isn't yet built
                    (in which case its weights aren't yet defined).
            """
            if not self.built:
              if self.__class__.__name__ == 'Sequential':
                self.build()  # pylint: disable=no-value-for-parameter
              else:
                raise RuntimeError('You tried to call `count_params` on ' + self.name +
                                   ', but the layer isn\'t built. '
                                   'You can build it manually via: `' + self.name +
                                   '.build(batch_input_shape)`.')
            return sum([K.count_params(p) for p in self.weights])
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def _updated_config(self):
            """Util hared between different serialization methods.

            Returns:
                Model config with Keras version information added.
            """
            from tensorflow.contrib.keras.python.keras import __version__ as keras_version  # pylint: disable=g-import-not-at-top

            config = self.get_config()
            model_config = {
                'class_name': self.__class__.__name__,
                'config': config,
                'keras_version': keras_version,
                'backend': K.backend()
            }
            return model_config
项目:keras-customized    作者:ambrite    | 项目源码 | 文件源码
def create_input_layer(self, batch_input_shape,
                           input_dtype=None, name=None):
        if not name:
            prefix = self.__class__.__name__.lower() + '_input_'
            name = prefix + str(K.get_uid(prefix))
        if not input_dtype:
            input_dtype = K.floatx()

        self.batch_input_shape = batch_input_shape
        self.input_dtype = input_dtype

        # Instantiate the input layer.
        x = Input(batch_shape=batch_input_shape,
                  dtype=input_dtype, name=name)
        # This will build the current layer
        # and create the node connecting the current layer
        # to the input layer we just created.
        self(x)
项目:keras-customized    作者:ambrite    | 项目源码 | 文件源码
def to_json(self, **kwargs):
        '''Returns a JSON string containing the network configuration.

        To load a network from a JSON save file, use
        `keras.models.model_from_json(json_string, custom_objects={})`.
        '''
        import json

        def get_json_type(obj):
            # If obj is any numpy type
            if type(obj).__module__ == np.__name__:
                return obj.item()

            # If obj is a python 'type'
            if type(obj).__name__ == type.__name__:
                return obj.__name__

            raise TypeError('Not JSON Serializable:', obj)

        model_config = self._updated_config()
        return json.dumps(model_config, default=get_json_type, **kwargs)
项目:keras-customized    作者:ambrite    | 项目源码 | 文件源码
def get_config(self):
        '''Returns the model configuration
        as a Python list.
        '''
        config = []
        if isinstance(self.layers[0], Merge):
            assert hasattr(self.layers[0], 'layers')
            layers = []
            for layer in self.layers[0].layers:
                layer_config = {'class_name': layer.__class__.__name__,
                                'config': layer.get_config()}
                layers.append(layer_config)
            merge_config = self.layers[0].get_config()
            merge_config['layers'] = layers
            config.append({'class_name': 'Merge', 'config': merge_config})
        else:
            config.append({'class_name': self.layers[0].__class__.__name__,
                           'config': self.layers[0].get_config()})
        for layer in self.layers[1:]:
            config.append({'class_name': layer.__class__.__name__,
                           'config': layer.get_config()})
        return copy.deepcopy(config)
项目:lstm_tensorflow_imdb    作者:AaronZhouQian    | 项目源码 | 文件源码
def binary_one_hot(x):
    try:
        if type(x).__module__ == np.__name__:
            dim0 = x.shape[0]
        elif isinstance(x, list):
            dim0 = len(x)
        else:
            raise TypeError
    except TypeError:
        print("Expecting input type to be one of {list, numpy.ndarray}. Received %s" % type(x))

    dim1 = 2
    output = np.zeros((dim0, dim1))
    for i in range(dim0):
        output[i, x[i]] = 1
    return output
项目:lstm_tensorflow_imdb    作者:AaronZhouQian    | 项目源码 | 文件源码
def binary_one_hot(x):
    try:
        if type(x).__module__ == np.__name__:
            dim0 = x.shape[0]
        elif isinstance(x, list):
            dim0 = len(x)
        else:
            raise TypeError
    except TypeError:
        print("Expecting input type to be one of {list, numpy.ndarray}. Received %s" % type(x))

    dim1 = 2
    output = np.zeros((dim0, dim1))
    for i in range(dim0):
        output[i, x[i]] = 1
    return output
项目:lstm_tensorflow_imdb    作者:AaronZhouQian    | 项目源码 | 文件源码
def binary_one_hot(x):
    try:
        if type(x).__module__ == np.__name__:
            dim0 = x.shape[0]
        elif isinstance(x, list):
            dim0 = len(x)
        else:
            raise TypeError
    except TypeError:
        print("Expecting input type to be one of {list, numpy.ndarray}. Received %s" % type(x))

    dim1 = 2
    output = np.zeros((dim0, dim1))
    for i in range(dim0):
        output[i, x[i]] = 1
    return output
项目:keras    作者:NVIDIA    | 项目源码 | 文件源码
def create_input_layer(self, batch_input_shape,
                           input_dtype=None, name=None):
        if not name:
            prefix = self.__class__.__name__.lower() + '_input_'
            name = prefix + str(K.get_uid(prefix))
        if not input_dtype:
            input_dtype = K.floatx()

        self.batch_input_shape = batch_input_shape
        self.input_dtype = input_dtype

        # Instantiate the input layer.
        x = Input(batch_shape=batch_input_shape,
                  dtype=input_dtype, name=name)
        # This will build the current layer
        # and create the node connecting the current layer
        # to the input layer we just created.
        self(x)
项目:keras    作者:NVIDIA    | 项目源码 | 文件源码
def to_json(self, **kwargs):
        """Returns a JSON string containing the network configuration.

        To load a network from a JSON save file, use
        `keras.models.model_from_json(json_string, custom_objects={})`.
        """
        import json

        def get_json_type(obj):
            # If obj is any numpy type
            if type(obj).__module__ == np.__name__:
                return obj.item()

            # If obj is a python 'type'
            if type(obj).__name__ == type.__name__:
                return obj.__name__

            raise TypeError('Not JSON Serializable:', obj)

        model_config = self._updated_config()
        return json.dumps(model_config, default=get_json_type, **kwargs)
项目:keras    作者:NVIDIA    | 项目源码 | 文件源码
def get_config(self):
        """Returns the model configuration
        as a Python list.
        """
        config = []
        if isinstance(self.layers[0], Merge):
            assert hasattr(self.layers[0], 'layers')
            layers = []
            for layer in self.layers[0].layers:
                layer_config = {'class_name': layer.__class__.__name__,
                                'config': layer.get_config()}
                layers.append(layer_config)
            merge_config = self.layers[0].get_config()
            merge_config['layers'] = layers
            config.append({'class_name': 'Merge', 'config': merge_config})
        else:
            config.append({'class_name': self.layers[0].__class__.__name__,
                           'config': self.layers[0].get_config()})
        for layer in self.layers[1:]:
            config.append({'class_name': layer.__class__.__name__,
                           'config': layer.get_config()})
        return copy.deepcopy(config)
项目:keras_superpixel_pooling    作者:parag2489    | 项目源码 | 文件源码
def compute_output_shape(self, input_shape):
        """Computes the output shape of the layer.

        Assumes that the layer will be built
        to match that input shape provided.

        # Arguments
            input_shape: Shape tuple (tuple of integers)
                or list of shape tuples (one per output tensor of the layer).
                Shape tuples can include None for free dimensions,
                instead of an integer.

        # Returns
            An input shape tuple.
        """
        if hasattr(self, 'get_output_shape_for'):
            msg = "Class `{}.{}` defines `get_output_shape_for` but does not override `compute_output_shape`. " + \
                  "If this is a Keras 1 layer, please implement `compute_output_shape` to support Keras 2."
            warnings.warn(msg.format(type(self).__module__, type(self).__name__), stacklevel=2)
        return input_shape
项目:keras_superpixel_pooling    作者:parag2489    | 项目源码 | 文件源码
def count_params(self):
        """Count the total number of scalars composing the weights.

        # Returns
            An integer count.

        # Raises
            RuntimeError: if the layer isn't yet built
                (in which case its weights aren't yet defined).
        """
        if not self.built:
            if self.__class__.__name__ == 'Sequential':
                self.build()
            else:
                raise RuntimeError('You tried to call `count_params` on ' +
                                   self.name + ', but the layer isn\'t built. '
                                   'You can build it manually via: `' +
                                   self.name + '.build(batch_input_shape)`.')
        return sum([K.count_params(p) for p in self.weights])
项目:keras_superpixel_pooling    作者:parag2489    | 项目源码 | 文件源码
def _updated_config(self):
        """Util hared between different serialization methods.

        # Returns
            Model config with Keras version information added.
        """
        from .. import __version__ as keras_version

        config = self.get_config()
        model_config = {
            'class_name': self.__class__.__name__,
            'config': config,
            'keras_version': keras_version,
            'backend': K.backend()
        }
        return model_config
项目:GPOF    作者:matt-42    | 项目源码 | 文件源码
def run_impl(self, params):

        # Convert numpy types.
        for k in list(params.keys()):
            a = params[k]
            if type(a).__module__ == np.__name__:
                params[k] = a.item()

        # Check if the paramset has not already run.
        run = self.runset.find_run(params)
        if run:
            return run

        # Run the function.
        r = self.to_optimise(params)

        if r is not None:
            # Merge params and result dicts.
            run = params.copy()
            run.update(r)

        return run
项目:InnerOuterRNN    作者:Chemoinformatics    | 项目源码 | 文件源码
def create_input_layer(self, batch_input_shape,
                           input_dtype=None, name=None):
        if not name:
            prefix = self.__class__.__name__.lower() + '_input_'
            name = prefix + str(K.get_uid(prefix))
        if not input_dtype:
            input_dtype = K.floatx()

        self.batch_input_shape = batch_input_shape
        self.input_dtype = input_dtype

        # instantiate the input layer
        x = Input(batch_shape=batch_input_shape,
                  dtype=input_dtype, name=name)
        # this will build the current layer
        # and create the node connecting the current layer
        # to the input layer we just created.
        self(x)
项目:InnerOuterRNN    作者:Chemoinformatics    | 项目源码 | 文件源码
def to_json(self, **kwargs):
        '''Returns a JSON string containing the network configuration.

        To load a network from a JSON save file, use
        `keras.models.model_from_json(json_string, custom_objects={})`.
        '''
        import json

        def get_json_type(obj):
            # if obj is any numpy type
            if type(obj).__module__ == np.__name__:
                return obj.item()

            # if obj is a python 'type'
            if type(obj).__name__ == type.__name__:
                return obj.__name__

            raise TypeError('Not JSON Serializable:', obj)

        model_config = self._updated_config()
        return json.dumps(model_config, default=get_json_type, **kwargs)
项目:InnerOuterRNN    作者:Chemoinformatics    | 项目源码 | 文件源码
def get_config(self):
        '''Returns the model configuration
        as a Python list.
        '''
        config = []
        if self.layers[0].__class__.__name__ == 'Merge':
            assert hasattr(self.layers[0], 'layers')
            layers = []
            for layer in self.layers[0].layers:
                layer_config = {'class_name': layer.__class__.__name__,
                                'config': layer.get_config()}
                layers.append(layer_config)
            merge_config = self.layers[0].get_config()
            merge_config['layers'] = layers
            config.append({'class_name': 'Merge', 'config': merge_config})
        else:
            config.append({'class_name': self.layers[0].__class__.__name__,
                           'config': self.layers[0].get_config()})
        for layer in self.layers[1:]:
            config.append({'class_name': layer.__class__.__name__,
                           'config': layer.get_config()})
        return copy.deepcopy(config)
项目:simple_rl    作者:david-abel    | 项目源码 | 文件源码
def __hash__(self):
        if type(self.data).__module__ == np.__name__:
            # Numpy arrays
            return hash(str(self.data))
        elif self.data.__hash__ is None:
            return hash(tuple(self.data))
        else:
            return hash(self.data)
项目:compresso    作者:VCG    | 项目源码 | 文件源码
def get_size(variable):
        '''Get bytes of variable
        '''
        if type(variable).__module__ == np.__name__:
            variable = variable.tobytes()
        elif type(variable) is str:
            assert (all(ord(c) < 256) for c in variable)
        else:
            raise ValueError('Data type not supported')

        # checking the length of a bytestring is more accurate
        return len(variable)
项目:pydisp    作者:dimatura    | 项目源码 | 文件源码
def dyplot(data, **kwargs):
    """ Plot data as line chart with dygraph
    Params:
        data: either a 2-d numpy array or a list of lists.
        win: pane id
        labels: list of series names, first series is always the X-axis
        see http://dygraphs.com/options.html for other supported options
    """
    win = kwargs.get('win') or uid()

    dataset = {}
    if type(data).__module__ == np.__name__:
        dataset = data.tolist()
    else:
        dataset = data

    # clone kwargs into options
    options = dict(kwargs)
    options['file'] = dataset
    if options.get('labels'):
        options['xlabel'] = options['labels'][0]

    # Don't pass our options to dygraphs.
    options.pop('win', None)

    return pane('plot', kwargs.get('win'), kwargs.get('title'), content=options)
项目:keras    作者:GeekLiB    | 项目源码 | 文件源码
def count_params(self):
        '''Returns the total number of floats (or ints)
        composing the weights of the layer.
        '''
        if not self.built:
            if self.__class__.__name__ == 'Sequential':
                self.build()
            else:
                raise Exception('You tried to call `count_params` on ' +
                                self.name + ', but the layer isn\'t built. '
                                'You can build it manually via: `' +
                                self.name + '.build(batch_input_shape)`.')
        return sum([K.count_params(p) for p in self.weights])
项目:keras    作者:GeekLiB    | 项目源码 | 文件源码
def get_config(self):
        if isinstance(self.mode, python_types.LambdaType):
            mode = func_dump(self.mode)
            mode_type = 'lambda'
        elif callable(self.mode):
            mode = self.mode.__name__
            mode_type = 'function'
        else:
            mode = self.mode
            mode_type = 'raw'

        if isinstance(self._output_shape, python_types.LambdaType):
            output_shape = func_dump(self._output_shape)
            output_shape_type = 'lambda'
        elif callable(self._output_shape):
            output_shape = self._output_shape.__name__
            output_shape_type = 'function'
        else:
            output_shape = self._output_shape
            output_shape_type = 'raw'

        if isinstance(self._output_mask, python_types.LambdaType):
            output_mask = func_dump(self._output_mask)
            output_mask_type = 'lambda'
        elif callable(self._output_mask):
            output_mask = self._output_mask.__name__
            output_mask_type = 'function'
        else:
            output_mask = self._output_mask
            output_mask_type = 'raw'

        return {'name': self.name,
                'mode': mode,
                'mode_type': mode_type,
                'concat_axis': self.concat_axis,
                'dot_axes': self.dot_axes,
                'output_shape': output_shape,
                'output_shape_type': output_shape_type,
                'output_mask': output_mask,
                'output_mask_type': output_mask_type,
                'arguments': self.arguments}
项目:deep-learning-nd    作者:RyanCCollins    | 项目源码 | 文件源码
def test_normalize(normalize):
    test_shape = (np.random.choice(range(1000)), 32, 32, 3)
    test_numbers = np.random.choice(range(256), test_shape)
    normalize_out = normalize(test_numbers)

    assert type(normalize_out).__module__ == np.__name__,\
        'Not Numpy Object'

    assert normalize_out.shape == test_shape,\
        'Incorrect Shape. {} shape found'.format(normalize_out.shape)

    assert normalize_out.max() <= 1 and normalize_out.min() >= 0,\
        'Incorect Range. {} to {} found'.format(normalize_out.min(), normalize_out.max())

    _print_success_message()
项目:deep-learning-nd    作者:RyanCCollins    | 项目源码 | 文件源码
def test_one_hot_encode(one_hot_encode):
    test_shape = np.random.choice(range(1000))
    test_numbers = np.random.choice(range(10), test_shape)
    one_hot_out = one_hot_encode(test_numbers)

    assert type(one_hot_out).__module__ == np.__name__,\
        'Not Numpy Object'

    assert one_hot_out.shape == (test_shape, 10),\
        'Incorrect Shape. {} shape found'.format(one_hot_out.shape)

    n_encode_tests = 5
    test_pairs = list(zip(test_numbers, one_hot_out))
    test_indices = np.random.choice(len(test_numbers), n_encode_tests)
    labels = [test_pairs[test_i][0] for test_i in test_indices]
    enc_labels = np.array([test_pairs[test_i][1] for test_i in test_indices])
    new_enc_labels = one_hot_encode(labels)

    assert np.array_equal(enc_labels, new_enc_labels),\
        'Encodings returned different results for the same numbers.\n' \
        'For the first call it returned:\n' \
        '{}\n' \
        'For the second call it returned\n' \
        '{}\n' \
        'Make sure you save the map of labels to encodings outside of the function.'.format(enc_labels, new_enc_labels)

    _print_success_message()
项目:gandlf    作者:codekansas    | 项目源码 | 文件源码
def save_model(model, filepath, overwrite=True):

    def get_json_type(obj):
        if hasattr(obj, 'get_config'):
            return {'class_name': obj.__class__.__name__,
                    'config': obj.get_config()}

        if type(obj).__module__ == np.__name__:
            return obj.item()

        if callable(obj) or type(obj).__name__ == type.__name__:
            return obj.__name__

        raise TypeError('Not JSON Serializable:', obj)

    import h5py
    from keras import __version__ as keras_version

    if not overwrite and os.path.isfile(filepath):
        proceed = keras.models.ask_to_proceed_with_overwrite(filepath)
        if not proceed:
            return

    f = h5py.File(filepath, 'w')
    f.attrs['keras_version'] = str(keras_version).encode('utf8')
    f.attrs['generator_config'] = json.dumps({
        'class_name': model.discriminator.__class__.__name__,
        'config': model.generator.get_config(),
    }, default=get_json_type).encode('utf8')
    f.attrs['discriminator_config'] = json.dumps({
        'class_name': model.discriminator.__class__.__name__,
        'config': model.discriminator.get_config(),
    }, default=get_json_type).encode('utf8')

    generator_weights_group = f.create_group('generator_weights')
    discriminator_weights_group = f.create_group('discriminator_weights')
    model.generator.save_weights_to_hdf5_group(generator_weights_group)
    model.discriminator.save_weights_to_hdf5_group(discriminator_weights_group)

    f.flush()
    f.close()
项目:supvisors    作者:julien6387    | 项目源码 | 文件源码
def test_suite():
    return unittest.findTestCases(sys.modules[__name__])
项目:deep-learning-keras-projects    作者:jasmeetsb    | 项目源码 | 文件源码
def count_params(self):
        """Returns the total number of floats (or ints)
        composing the weights of the layer.
        """
        if not self.built:
            if self.__class__.__name__ == 'Sequential':
                self.build()
            else:
                raise RuntimeError('You tried to call `count_params` on ' +
                                   self.name + ', but the layer isn\'t built. '
                                   'You can build it manually via: `' +
                                   self.name + '.build(batch_input_shape)`.')
        return sum([K.count_params(p) for p in self.weights])
项目:deep-learning-keras-projects    作者:jasmeetsb    | 项目源码 | 文件源码
def get_config(self):
        if isinstance(self.mode, python_types.LambdaType):
            mode = func_dump(self.mode)
            mode_type = 'lambda'
        elif callable(self.mode):
            mode = self.mode.__name__
            mode_type = 'function'
        else:
            mode = self.mode
            mode_type = 'raw'

        if isinstance(self._output_shape, python_types.LambdaType):
            output_shape = func_dump(self._output_shape)
            output_shape_type = 'lambda'
        elif callable(self._output_shape):
            output_shape = self._output_shape.__name__
            output_shape_type = 'function'
        else:
            output_shape = self._output_shape
            output_shape_type = 'raw'

        if isinstance(self._output_mask, python_types.LambdaType):
            output_mask = func_dump(self._output_mask)
            output_mask_type = 'lambda'
        elif callable(self._output_mask):
            output_mask = self._output_mask.__name__
            output_mask_type = 'function'
        else:
            output_mask = self._output_mask
            output_mask_type = 'raw'

        return {'name': self.name,
                'mode': mode,
                'mode_type': mode_type,
                'concat_axis': self.concat_axis,
                'dot_axes': self.dot_axes,
                'output_shape': output_shape,
                'output_shape_type': output_shape_type,
                'output_mask': output_mask,
                'output_mask_type': output_mask_type,
                'arguments': self.arguments}
项目:SPHERE-HyperStream    作者:IRC-SPHERE    | 项目源码 | 文件源码
def serialise_to_json(obj):
    """

    :param model:
    :return:
    """

    if obj is dict:
        return serialise_dict(obj)

    params = {}

    for kk, vv in obj.__dict__.iteritems():
        try:
            if isinstance(vv, type):
                continue

            if vv is None:
                params[kk] = None

            elif type(vv).__module__ == numpy_name:
                params[kk] = vv.tolist()

            elif isinstance(vv, dict):
                params[kk] = serialise_dict(vv)

            elif isinstance(vv, (str, list, bool, int, float)):
                params[kk] = vv

        except Exception as ex:
            raise ex

    return params
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def get_config(self):
        config = []
        for layer in self.layers:
          config.append({
              'class_name': layer.__class__.__name__,
              'config': layer.get_config()
          })
        return copy.deepcopy(config)
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def fit(self, x, y, **kwargs):
            """Constructs a new model with `build_fn` & fit the model to `(x, y)`.

            Arguments:
                x : array-like, shape `(n_samples, n_features)`
                    Training samples where n_samples in the number of samples
                    and n_features is the number of features.
                y : array-like, shape `(n_samples,)` or `(n_samples, n_outputs)`
                    True labels for X.
                **kwargs: dictionary arguments
                    Legal arguments are the arguments of `Sequential.fit`

            Returns:
                history : object
                    details about the training history at each epoch.
            """
            if self.build_fn is None:
              self.model = self.__call__(**self.filter_sk_params(self.__call__))
            elif (not isinstance(self.build_fn, types.FunctionType) and
                  not isinstance(self.build_fn, types.MethodType)):
              self.model = self.build_fn(
                  **self.filter_sk_params(self.build_fn.__call__))
            else:
              self.model = self.build_fn(**self.filter_sk_params(self.build_fn))

            loss_name = self.model.loss
            if hasattr(loss_name, '__name__'):
              loss_name = loss_name.__name__
            if loss_name == 'categorical_crossentropy' and len(y.shape) != 2:
              y = to_categorical(y)

            fit_args = copy.deepcopy(self.filter_sk_params(Sequential.fit))
            fit_args.update(kwargs)

            history = self.model.fit(x, y, **fit_args)

            return history
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def score(self, x, y, **kwargs):
            """Returns the mean accuracy on the given test data and labels.

            Arguments:
                x: array-like, shape `(n_samples, n_features)`
                    Test samples where n_samples in the number of samples
                    and n_features is the number of features.
                y: array-like, shape `(n_samples,)` or `(n_samples, n_outputs)`
                    True labels for x.
                **kwargs: dictionary arguments
                    Legal arguments are the arguments of `Sequential.evaluate`.

            Returns:
                score: float
                    Mean accuracy of predictions on X wrt. y.

            Raises:
                ValueError: If the underlying model isn't configured to
                    compute accuracy. You should pass `metrics=["accuracy"]` to
                    the `.compile()` method of the model.
            """
            y = np.searchsorted(self.classes_, y)
            kwargs = self.filter_sk_params(Sequential.evaluate, kwargs)

            loss_name = self.model.loss
            if hasattr(loss_name, '__name__'):
              loss_name = loss_name.__name__
            if loss_name == 'categorical_crossentropy' and len(y.shape) != 2:
              y = to_categorical(y)

            outputs = self.model.evaluate(x, y, **kwargs)
            if not isinstance(outputs, list):
              outputs = [outputs]
            for name, output in zip(self.model.metrics_names, outputs):
              if name == 'acc':
                return output
            raise ValueError('The model is not configured to compute accuracy. '
                             'You should pass `metrics=["accuracy"]` to '
                             'the `model.compile()` method.')
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def serialize_keras_object(instance):
          _, instance = tf_decorator.unwrap(instance)
          if instance is None:
            return None
          if hasattr(instance, 'get_config'):
            return {
                'class_name': instance.__class__.__name__,
                'config': instance.get_config()
            }
          if hasattr(instance, '__name__'):
            return instance.__name__
          else:
            raise ValueError('Cannot serialize', instance)
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def get_config(self):
            if isinstance(self.function, python_types.LambdaType):
              function = func_dump(self.function)
              function_type = 'lambda'
            else:
              function = self.function.__name__
              function_type = 'function'

            config = {
                'function': function,
                'function_type': function_type,
                'arguments': self.arguments
            }
            base_config = super(Lambda, self).get_config()
            return dict(list(base_config.items()) + list(config.items()))
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def serialize(layer):
          return {'class_name': layer.__class__.__name__, 'config': layer.get_config()}
项目:LIE    作者:EmbraceLife    | 项目源码 | 文件源码
def get_config(self):
            config = {
                'layer': {
                    'class_name': self.layer.__class__.__name__,
                    'config': self.layer.get_config()
                }
            }
            base_config = super(Wrapper, self).get_config()
            return dict(list(base_config.items()) + list(config.items()))
项目:keras-customized    作者:ambrite    | 项目源码 | 文件源码
def count_params(self):
        '''Returns the total number of floats (or ints)
        composing the weights of the layer.
        '''
        if not self.built:
            if self.__class__.__name__ == 'Sequential':
                self.build()
            else:
                raise RuntimeError('You tried to call `count_params` on ' +
                                   self.name + ', but the layer isn\'t built. '
                                   'You can build it manually via: `' +
                                   self.name + '.build(batch_input_shape)`.')
        return sum([K.count_params(p) for p in self.weights])
项目:keras-customized    作者:ambrite    | 项目源码 | 文件源码
def get_config(self):
        if isinstance(self.mode, python_types.LambdaType):
            mode = func_dump(self.mode)
            mode_type = 'lambda'
        elif callable(self.mode):
            mode = self.mode.__name__
            mode_type = 'function'
        else:
            mode = self.mode
            mode_type = 'raw'

        if isinstance(self._output_shape, python_types.LambdaType):
            output_shape = func_dump(self._output_shape)
            output_shape_type = 'lambda'
        elif callable(self._output_shape):
            output_shape = self._output_shape.__name__
            output_shape_type = 'function'
        else:
            output_shape = self._output_shape
            output_shape_type = 'raw'

        if isinstance(self._output_mask, python_types.LambdaType):
            output_mask = func_dump(self._output_mask)
            output_mask_type = 'lambda'
        elif callable(self._output_mask):
            output_mask = self._output_mask.__name__
            output_mask_type = 'function'
        else:
            output_mask = self._output_mask
            output_mask_type = 'raw'

        return {'name': self.name,
                'mode': mode,
                'mode_type': mode_type,
                'concat_axis': self.concat_axis,
                'dot_axes': self.dot_axes,
                'output_shape': output_shape,
                'output_shape_type': output_shape_type,
                'output_mask': output_mask,
                'output_mask_type': output_mask_type,
                'arguments': self.arguments}
项目:commercials_project    作者:BryceLuna    | 项目源码 | 文件源码
def get_data(self,):
        if not self.file_lst2 and type(self.file_lst2[0][0]).__module__ == np.__name__:
            self._vectorize_labels()
            for pair in zip(self.file_lst2,self.labels):
                #TODO