Python config.NUM_CLASSES属性代码示例

# 需要导入模块: import config [as 别名]
# 或者: from config import NUM_CLASSES [as 别名]
def __init__(self, layer_params):
        super(ResNetTypeII, self).__init__()
        self.conv1 = tf.keras.layers.Conv2D(filters=64,
                                            kernel_size=(7, 7),
                                            strides=2,
                                            padding="same")
        self.bn1 = tf.keras.layers.BatchNormalization()
        self.pool1 = tf.keras.layers.MaxPool2D(pool_size=(3, 3),
                                               strides=2,
                                               padding="same")

        self.layer1 = make_bottleneck_layer(filter_num=64,
                                            blocks=layer_params[0])
        self.layer2 = make_bottleneck_layer(filter_num=128,
                                            blocks=layer_params[1],
                                            stride=2)
        self.layer3 = make_bottleneck_layer(filter_num=256,
                                            blocks=layer_params[2],
                                            stride=2)
        self.layer4 = make_bottleneck_layer(filter_num=512,
                                            blocks=layer_params[3],
                                            stride=2)

        self.avgpool = tf.keras.layers.GlobalAveragePooling2D()
        self.fc = tf.keras.layers.Dense(units=NUM_CLASSES, activation=tf.keras.activations.softmax) 

# 需要导入模块: import config [as 别名]
# 或者: from config import NUM_CLASSES [as 别名]
def processor(sample):
    data, labels, training = sample

    data = utils.augmentation(data.unsqueeze(1).float() / 255.0)
    labels = torch.eye(config.NUM_CLASSES).index_select(dim=0, index=labels)

    data = Variable(data)
    labels = Variable(labels)
    if torch.cuda.is_available():
        data = data.cuda()
        labels = labels.cuda()

    if training:
        classes, reconstructions = model(data, labels)
    else:
        classes, reconstructions = model(data)

    loss = capsule_loss(data, labels, classes, reconstructions)

    return loss, classes 

# 需要导入模块: import config [as 别名]
# 或者: from config import NUM_CLASSES [as 别名]
def __init__(self):
        super(CapsuleNet, self).__init__()

        self.conv1 = nn.Conv2d(in_channels=1, out_channels=256, kernel_size=9, stride=1)
        self.primary_capsules = CapsuleLayer(num_capsules=8, num_route_nodes=-1, in_channels=256, out_channels=32,
                                             kernel_size=9, stride=2)
        self.digit_capsules = CapsuleLayer(num_capsules=config.NUM_CLASSES, num_route_nodes=32 * 6 * 6, in_channels=8,
                                           out_channels=16)

        self.decoder = nn.Sequential(
            nn.Linear(16 * config.NUM_CLASSES, 512),
            nn.ReLU(inplace=True),
            nn.Linear(512, 1024),
            nn.ReLU(inplace=True),
            nn.Linear(1024, 784),
            nn.Sigmoid()
        ) 

# 需要导入模块: import config [as 别名]
# 或者: from config import NUM_CLASSES [as 别名]
def forward(self, x, y=None):
        x = F.relu(self.conv1(x), inplace=True)
        x = self.primary_capsules(x)
        x = self.digit_capsules(x).squeeze().transpose(0, 1)

        classes = (x ** 2).sum(dim=-1) ** 0.5
        classes = F.softmax(classes, dim=-1)

        if y is None:
            # In all batches, get the most active capsule.
            _, max_length_indices = classes.max(dim=1)
            if torch.cuda.is_available():
                y = Variable(torch.eye(config.NUM_CLASSES)).cuda().index_select(dim=0, index=max_length_indices)
            else:
                y = Variable(torch.eye(config.NUM_CLASSES)).index_select(dim=0, index=max_length_indices)
        reconstructions = self.decoder((x * y[:, :, None]).view(x.size(0), -1))

        return classes, reconstructions 

# 需要导入模块: import config [as 别名]
# 或者: from config import NUM_CLASSES [as 别名]
def __init__(self, model_file=PATH_TO_CKPT, label_file=PATH_TO_LABELS):
        logger.info('Loading model from: {}...'.format(model_file))
        detection_graph = tf.Graph()
        graph = tf.Graph()
        with tf.Session(graph=detection_graph):
            # load the graph ===
            # loading a (frozen) TensorFlow model into memory

            with graph.as_default():
                od_graph_def = tf.GraphDef()
                with tf.gfile.GFile(model_file, 'rb') as fid:
                    serialized_graph = fid.read()
                    od_graph_def.ParseFromString(serialized_graph)
                    tf.import_graph_def(od_graph_def, name='')

                # loading a label map
                label_map = label_map_util.load_labelmap(label_file)
                categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES,
                                                                            use_display_name=True)
                category_index = label_map_util.create_category_index(categories)

        # set up instance variables
        self.graph = graph
        self.category_index = category_index
        self.categories = categories 

# 需要导入模块: import config [as 别名]
# 或者: from config import NUM_CLASSES [as 别名]
def label_to_array(label):
    try:
        label_array = np.zeros((25, config.NUM_CLASSES))
        for i in range(len(label)):
            try:
                label_array[i, config.CHAR_VECTOR.index(label[i])] = 1
            except Exception as ex:
                label_array[i, 0] = 1
        return label_array
    except Exception as ex:
        print(label)
        raise ex 

# 需要导入模块: import config [as 别名]
# 或者: from config import NUM_CLASSES [as 别名]
def __generate_all_train_batches(self):
        train_batches = []
        while not self.current_train_offset + self.batch_size > self.test_offset:
            old_offset = self.current_train_offset

            new_offset = self.current_train_offset + self.batch_size

            self.current_train_offset = new_offset

            raw_batch_x, raw_batch_y, raw_batch_la, raw_batch_la_2 = zip(*self.data[old_offset:new_offset])

            batch_y = np.reshape(
                np.array(raw_batch_y),
                (-1)
            )

            batch_seq_len = np.reshape(
                [len(y) for y in raw_batch_y],
                (-1)
            )

            batch_dt = np.reshape(
                np.array(raw_batch_la),
                (-1, 25, config.NUM_CLASSES)
            )

            batch_dt_2 = np.reshape(
                np.array(raw_batch_la_2),
                (-1, 25)
            )

            batch_x = np.reshape(
                np.array(raw_batch_x),
                (-1, self.max_image_width, 32, 1)
            )

            train_batches.append((batch_y, batch_seq_len, batch_dt, batch_dt_2, batch_x))
        return train_batches 

# 需要导入模块: import config [as 别名]
# 或者: from config import NUM_CLASSES [as 别名]
def __generate_all_test_batches(self):
        test_batches = []
        while not self.current_test_offset + self.batch_size > self.data_len:
            old_offset = self.current_test_offset

            new_offset = self.current_test_offset + self.batch_size

            self.current_test_offset = new_offset

            raw_batch_x, raw_batch_y, raw_batch_la, _ = zip(*self.data[old_offset:new_offset])

            batch_y = np.reshape(
                np.array(raw_batch_y),
                (-1)
            )

            batch_dt = np.zeros(
                np.shape(
                    np.reshape(
                        np.array(raw_batch_la),
                        (-1, 25, config.NUM_CLASSES)
                    )
                )
            )

            batch_x = np.reshape(
                np.array(raw_batch_x),
                (-1, self.max_image_width, 32, 1)
            )

            test_batches.append((batch_y, batch_dt, batch_x))
        return test_batches