def hackrf_raw_IQ_format(ppm):
"""
real_signal = []
bits = numpy.unpackbits(numpy.asarray(ppm, dtype=numpy.uint8))
for bit in bits:
if bit == 1:
I = 127
else:
I = 0
real_signal.append(I)
analytic_signal = hilbert(real_signal)
#for i in range(len(real_signal)):
# print i, real_signal[i], int(analytic_signal[i])
"""
signal = []
bits = numpy.unpackbits(numpy.asarray(ppm, dtype=numpy.uint8))
for bit in bits:
if bit == 1:
I = 127
Q = 127
else:
I = 0
Q = 0
signal.append(I)
signal.append(Q)
return bytearray(signal)
python类unpackbits()的实例源码
def lsb_encode(data, image):
bytes_io = BytesIO()
dump(data, file=bytes_io)
data_bytes = bytes_io.getvalue()
data_bytes_array = np.fromiter(data_bytes, dtype=np.uint8)
data_bits_list = np.unpackbits(data_bytes_array).tolist()
data_bits_list += [0] * (image.size[0] * image.size[1] - len(data_bits_list))
watermark = Image.frombytes(data=bytes(data_bits_list), size=image.size, mode='L')
red, green, blue = image.split()
watermarked_red = ImageMath.eval("convert(a&0xFE|b&0x1,'L')", a=red, b=watermark)
watermarked_image = Image.merge("RGB", (watermarked_red, green, blue))
return watermarked_image
def main():
import numpy.random as random
from trace import trace
import sys
if len(sys.argv) == 1:
sys.exit("{} [directory]".format(sys.argv[0]))
directory = sys.argv[1]
directory_ad = "{}_ad/".format(directory)
discriminator = Discriminator(directory_ad).load()
name = "generated_actions.csv"
N = discriminator.net.input_shape[1]
lowbit = 20
highbit = N - lowbit
print("batch size: {}".format(2**lowbit))
xs = (((np.arange(2**lowbit )[:,None] & (1 << np.arange(N)))) > 0).astype(int)
# xs_h = (((np.arange(2**highbit)[:,None] & (1 << np.arange(highbit)))) > 0).astype(int)
try:
print(discriminator.local(name))
with open(discriminator.local(name), 'wb') as f:
for i in range(2**highbit):
print("Iteration {}/{} base: {}".format(i,2**highbit,i*(2**lowbit)), end=' ')
# h = np.binary_repr(i*(2**lowbit), width=N)
# print(h)
# xs_h = np.unpackbits(np.array([i*(2**lowbit)],dtype=int))
xs_h = (((np.array([i])[:,None] & (1 << np.arange(highbit)))) > 0).astype(int)
xs[:,lowbit:] = xs_h
# print(xs_h)
# print(xs[:10])
ys = discriminator.discriminate(xs,batch_size=100000)
ind = np.where(ys > 0.5)
valid_xs = xs[ind]
print(len(valid_xs))
np.savetxt(f,valid_xs,"%d")
except KeyboardInterrupt:
print("dump stopped")
def test_unpackbits():
# Copied from the docstring.
a = np.array([[2], [7], [23]], dtype=np.uint8)
b = np.unpackbits(a, axis=1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1]]))
def make_cmap(N_CLASSES):
# Generate the colors for the classes (with background class being 0,0,0)
c_size = 2**N_CLASSES - 1
cmap = np.concatenate([[[0, 0, 0]], plt.cm.Set1(np.arange(c_size) / (c_size))[:, :3]])
cmap = (cmap * 255).astype(np.uint8)
assert N_CLASSES <= 8, "ARGH!! can not handle more than 8 classes"
c_full_label = np.unpackbits(np.arange(2 ** N_CLASSES).astype(np.uint8)[:, None], axis=-1)[:, -N_CLASSES:]
return cmap, c_full_label
def decompress_raw(data, # type: bytes
shape, # type: Tuple[int, int]
depth, # type: int
version # type: int
): # type: (...) -> np.ndarray
"""
Converts raw data to a Numpy array.
{}
"""
depth = enums.ColorDepth(depth)
dtype = color_depth_dtype_map[depth]
itemsize = color_depth_size_map[depth]
# Truncate the data to a multiple of the dtype size
data = data[:(len(data) // itemsize) * itemsize]
arr = np.frombuffer(data, dtype)
if depth == 1:
# Unpack 1-bit image data
arr = np.unpackbits(arr)
# Make 2-dimensional
image = arr.reshape(shape)
return image
def parse_rectangle(cls, client, x, y, width, height, data):
split = width * height * client.framebuffer.bypp
image = np.frombuffer(data[:split], np.uint8).reshape((height, width, 4))[:, :, [0, 1, 2]]
# Turn raw bytes into uint8 array
mask = np.frombuffer(data[split:], np.uint8)
# Turn uint8 array into bit array, and go over the scanlines
mask = np.unpackbits(mask).reshape((height, -1 if mask.size else 0))[:, :width]
encoding = cls(image, mask)
return Rectangle(x, y, width, height, encoding)
def read(filename):
with gzip.open(filename, "rb") as f:
header_bytes = f.read(CHUNK_HEADER_SIZE)
data_size, board_size, input_planes, is_test = struct.unpack(CHUNK_HEADER_FORMAT, header_bytes)
position_dims = data_size * board_size * board_size * input_planes
next_move_dims = data_size * board_size * board_size
# the +7 // 8 compensates for numpy's bitpacking padding
packed_position_bytes = f.read((position_dims + 7) // 8)
packed_next_move_bytes = f.read((next_move_dims + 7) // 8)
# should have cleanly finished reading all bytes from file!
assert len(f.read()) == 0
flat_position = np.unpackbits(np.fromstring(packed_position_bytes, dtype=np.uint8))[:position_dims]
flat_nextmoves = np.unpackbits(np.fromstring(packed_next_move_bytes, dtype=np.uint8))[:next_move_dims]
pos_features = flat_position.reshape(data_size, board_size, board_size, input_planes)
next_moves = flat_nextmoves.reshape(data_size, board_size * board_size)
return DataSet(pos_features, next_moves, [], is_test=is_test)
def unpack(a, size):
"""From a packed array *a*, return the boolean array. Remove byte padding at the end."""
return np.unpackbits(a)[:size]
def test_unpackbits():
# Copied from the docstring.
a = np.array([[2], [7], [23]], dtype=np.uint8)
b = np.unpackbits(a, axis=1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1]]))
def imageToBoolMasks(arr):
'''inverse of [boolMasksToImage]'''
assert arr.dtype == np.uint8, 'image needs to be dtype=uint8'
masks = np.unpackbits(arr).reshape(*arr.shape, 8)
return np.swapaxes(masks, 2, 0)
def to_bit_sequence(self, event):
""" Creates an array of bits containing the details in the event
dictionary. Once created, the array is cached to speed up future writes.
Parameters
----------
event: dict
A dictionary describing the current component event. It should have
3 keys: name, action, and metadata.
Returns
-------
The array of bits
"""
if event["metadata"] is None:
nbytes = self.action_bytes + self.name_bytes
metadata_array = []
else:
nbytes = self.metadata_bytes + self.action_bytes + self.name_bytes
try:
metadata_array = np.fromstring(event["metadata"],
dtype=np.uint16).astype(np.uint8)[:self.metadata_bytes]
except TypeError:
metadata_array = np.array(map(ord,
event["metadata"].ljust(self.metadata_bytes)[:self.metadata_bytes]),
dtype=np.uint8)
int8_array = np.zeros(nbytes, dtype="uint8")
int8_array[:self.name_bytes] = map(ord, event["name"].ljust(self.name_bytes)[:self.name_bytes])
int8_array[self.name_bytes:self.name_bytes + self.action_bytes] = map(ord, event["action"].ljust(self.action_bytes)[:self.action_bytes])
int8_array[self.name_bytes + self.action_bytes:] = metadata_array
sequence = ([True] +
np.unpackbits(int8_array).astype(bool).tolist() +
[False])
key = (event["name"], event["action"], event["metadata"])
self.map_to_bit[key] = sequence
return sequence
def test_unpackbits():
# Copied from the docstring.
a = np.array([[2], [7], [23]], dtype=np.uint8)
b = np.unpackbits(a, axis=1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1]]))
def map_RB_data(data, datadepth):
""" Map BLOB data to correct DataWidth and Type and convert it
to numpy array
Parameters
----------
data : string
Blob Data
datadepth : int
bit depth of Blob data
Returns
-------
data : numpy array
Content of blob
"""
flagdepth = None
if datadepth < 8:
flagdepth = datadepth
datadepth = 8
datawidth, datatype = get_RB_data_layout(datadepth)
# import from data buffer well aligned to data array
data = np.ndarray(shape=(int(len(data) / datawidth),),
dtype=datatype, buffer=data)
if flagdepth:
data = np.unpackbits(data)
return data
def unpack_layer(plane):
"""Return a correctly shaped numpy array given the feature layer bytes."""
size = point.Point.build(plane.size)
if size == (0, 0):
# New layer that isn't implemented in this SC2 version.
return None
data = np.fromstring(plane.data, dtype=Feature.dtypes[plane.bits_per_pixel])
if plane.bits_per_pixel == 1:
data = np.unpackbits(data)
return data.reshape(size.transpose())
def test_unpackbits():
# Copied from the docstring.
a = np.array([[2], [7], [23]], dtype=np.uint8)
b = np.unpackbits(a, axis=1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1]]))
def test_unpackbits():
# Copied from the docstring.
a = np.array([[2], [7], [23]], dtype=np.uint8)
b = np.unpackbits(a, axis=1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1]]))
def test_unpackbits_empty():
a = np.empty((0,), dtype=np.uint8)
b = np.unpackbits(a)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.empty((0,)))
def test_unpackbits_empty_with_axis():
# Lists of packed shapes for different axes and unpacked shapes.
shapes = [
([(0,)], (0,)),
([(2, 24, 0), (16, 3, 0), (16, 24, 0)], (16, 24, 0)),
([(2, 0, 24), (16, 0, 24), (16, 0, 3)], (16, 0, 24)),
([(0, 16, 24), (0, 2, 24), (0, 16, 3)], (0, 16, 24)),
([(3, 0, 0), (24, 0, 0), (24, 0, 0)], (24, 0, 0)),
([(0, 24, 0), (0, 3, 0), (0, 24, 0)], (0, 24, 0)),
([(0, 0, 24), (0, 0, 24), (0, 0, 3)], (0, 0, 24)),
([(0, 0, 0), (0, 0, 0), (0, 0, 0)], (0, 0, 0)),
]
for in_shapes, out_shape in shapes:
for ax, in_shape in enumerate(in_shapes):
a = np.empty(in_shape, dtype=np.uint8)
b = np.unpackbits(a, axis=ax)
assert_equal(b.dtype, np.uint8)
assert_equal(b.shape, out_shape)
def unpack_state(self, s, shape):
a = np.fromstring(s, dtype=np.uint8)
a = np.unpackbits(a)
a = a.reshape(shape[0], -1)
a = a[:, :shape[1]]
b = np.zeros_like(a[0], np.int)
b[a[0] == 1] = Board.STONE_BLACK
b[a[1] == 1] = Board.STONE_WHITE
b[a[2] == 1] = Board.STONE_EMPTY
return b
def _read_data(self, fh, byteorder='>'):
"""Return image data from open file as numpy array."""
fh.seek(len(self.header))
data = fh.read()
dtype = 'u1' if self.maxval < 256 else byteorder + 'u2'
depth = 1 if self.magicnum == b"P7 332" else self.depth
shape = [-1, self.height, self.width, depth]
size = functools.reduce(operator.mul, shape[1:], 1) # prod()
if self.magicnum in b"P1P2P3":
data = numpy.array(data.split(None, size)[:size], dtype)
data = data.reshape(shape)
elif self.maxval == 1:
shape[2] = int(math.ceil(self.width / 8))
data = numpy.frombuffer(data, dtype).reshape(shape)
data = numpy.unpackbits(data, axis=-2)[:, :, :self.width, :]
else:
size *= numpy.dtype(dtype).itemsize
data = numpy.frombuffer(data[:size], dtype).reshape(shape)
if data.shape[0] < 2:
data = data.reshape(data.shape[1:])
if data.shape[-1] < 2:
data = data.reshape(data.shape[:-1])
if self.magicnum == b"P7 332":
rgb332 = numpy.array(list(numpy.ndindex(8, 8, 4)), numpy.uint8)
rgb332 *= [36, 36, 85]
data = numpy.take(rgb332, data, axis=0)
return data
def _generate_hypercube(samples, dimensions, rng):
"""Returns distinct binary samples of length dimensions
"""
if dimensions > 30:
return np.hstack([_generate_hypercube(samples, dimensions - 30, rng),
_generate_hypercube(samples, 30, rng)])
out = astype(sample_without_replacement(2 ** dimensions, samples,
random_state=rng),
dtype='>u4', copy=False)
out = np.unpackbits(out.view('>u1')).reshape((-1, 32))[:, -dimensions:]
return out
def test_unpackbits():
# Copied from the docstring.
a = np.array([[2], [7], [23]], dtype=np.uint8)
b = np.unpackbits(a, axis=1)
assert_equal(b.dtype, np.uint8)
assert_array_equal(b, np.array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1]]))
def unpackints(data, dtype, itemsize, runlen=0):
"""Decompress byte string to array of integers of any bit size <= 32.
Parameters
----------
data : byte str
Data to decompress.
dtype : numpy.dtype or str
A numpy boolean or integer type.
itemsize : int
Number of bits per integer.
runlen : int
Number of consecutive integers, after which to start at next byte.
"""
if itemsize == 1: # bitarray
data = numpy.fromstring(data, '|B')
data = numpy.unpackbits(data)
if runlen % 8:
data = data.reshape(-1, runlen + (8 - runlen % 8))
data = data[:, :runlen].reshape(-1)
return data.astype(dtype)
dtype = numpy.dtype(dtype)
if itemsize in (8, 16, 32, 64):
return numpy.fromstring(data, dtype)
if itemsize < 1 or itemsize > 32:
raise ValueError("itemsize out of range: %i" % itemsize)
if dtype.kind not in "biu":
raise ValueError("invalid dtype")
itembytes = next(i for i in (1, 2, 4, 8) if 8 * i >= itemsize)
if itembytes != dtype.itemsize:
raise ValueError("dtype.itemsize too small")
if runlen == 0:
runlen = len(data) // itembytes
skipbits = runlen*itemsize % 8
if skipbits:
skipbits = 8 - skipbits
shrbits = itembytes*8 - itemsize
bitmask = int(itemsize*'1'+'0'*shrbits, 2)
dtypestr = '>' + dtype.char # dtype always big endian?
unpack = struct.unpack
l = runlen * (len(data)*8 // (runlen*itemsize + skipbits))
result = numpy.empty((l, ), dtype)
bitcount = 0
for i in range(len(result)):
start = bitcount // 8
s = data[start:start+itembytes]
try:
code = unpack(dtypestr, s)[0]
except Exception:
code = unpack(dtypestr, s + b'\x00'*(itembytes-len(s)))[0]
code <<= bitcount % 8
code &= bitmask
result[i] = code >> shrbits
bitcount += itemsize
if (i+1) % runlen == 0:
bitcount += skipbits
return result
def to_bit_sequence(self, event):
""" Creates an array of bits containing the details in the event
dictionary. This array is then upsampled and converted to float64 to be
sent down an analog output. Once created, the array is cached to speed
up future calls.
Parameters
----------
event: dict
A dictionary describing the current component event. It should have
3 keys: name, action, and metadata.
Returns
-------
The array of bits expressed as analog values
"""
key = (event["name"], event["action"], event["metadata"])
# Check if the bit string is already stored
if key in self.map_to_bit:
return self.map_to_bit[key]
trim = lambda ss, l: ss.ljust(l)[:l]
# Set up int8 arrays where strings are converted to integers using ord
name_array = np.array(map(ord, trim(event["name"], self.name_bytes)),
dtype=np.uint8)
action_array = np.array(map(ord, trim(event["action"],
self.action_bytes)),
dtype=np.uint8)
# Add the metadata array if a value was passed
if event["metadata"] is not None:
metadata_array = np.array(map(ord, trim(event["metadata"],
self.metadata_bytes)),
dtype=np.uint8)
else:
metadata_array = np.array([], dtype=np.uint8)
sequence = ([True] +
np.unpackbits(name_array).astype(bool).tolist() +
np.unpackbits(action_array).astype(bool).tolist() +
np.unpackbits(metadata_array).astype(bool).tolist() +
[False])
sequence = np.repeat(sequence, self.upsample_factor).astype("float64")
sequence *= self.scaling
self.map_to_bit[key] = sequence
return sequence
def train():
X, m = get_data(['x', 'm'])
# X_train, X_test, m_train, m_test = get_data(['x', 'm'])
# for board in X_train[:2] :
# show_board( board )
start = time.time()
print 'shuffling...',
idx = range(len(X))
random.shuffle(idx)
X, m = X[idx], m[idx]
print '%.2f sec' % (time.time() - start)
# unpack the bits
start = time.time()
print 'unpacking...',
X = np.array([numpy.unpackbits(x).reshape(28, 8, 8).astype(np.bool) for x in X])
print '%.2f sec' % (time.time() - start)
model, name = make_model()
print 'compiling...' # 5e5 too high on 2017-09-06
sgd = SGD(lr=3e-5, decay=1e-6, momentum=0.9, nesterov=True) # 1e-4 : nan, 1e-5 loss 137 epoch1, 5e-5 loss 121 epoch1
# model.compile(loss='squared_hinge', optimizer='adadelta')
# model.compile(loss='mean_squared_error', optimizer='adadelta')
model.compile(loss='mean_squared_error', optimizer=sgd)
early_stopping = EarlyStopping( monitor = 'loss', patience = 50 ) # monitor='val_loss', verbose=0, mode='auto'
#print 'fitting...'
history = model.fit( X, m, nb_epoch = 10, batch_size = BATCH_SIZE, validation_split=0.05) #, callbacks = [early_stopping]) #, validation_split=0.05) #, verbose=2) #, show_accuracy = True )
# print 'evaluating...'
# score = model.evaluate(X_test, m_test, batch_size = BATCH_SIZE )
# print 'score:', score
now = datetime.datetime.now()
suffix = str(now.strftime("%Y-%m-%d_%H%M%S"))
model.save_weights( name.replace( '.model', '_%s.model' % suffix), overwrite = True )
#print X_train[:10]
# print m_train[:20]
# print model.predict( X_train[:20], batch_size = 5 )
# print m[:20]
# print model.predict( X[:20], batch_size = 5 )
result = zip( m[-20:] * 100.0, model.predict( X[-20:], batch_size = 5 ) * 100.0)
for a, b in result :
print '%.4f %.4f %.2f%%' % (a, b, abs(a-b) * 100.0 / max(abs(a),abs(b)))
# print m_test[:20]
# print model.predict( X_test[:20], batch_size = 5 )
# with open( MODEL_DATA + '.history', 'w') as fout :
# print >>fout, history.losses
