def test_array(setup_cluster): import dask.array as da from numpy.core.numeric import array_equal x = da.random.random((10000, 10000), chunks=(1000, 1000)) y = x + x.T z = y[::2, 5000:].mean(axis=1) dask_res = z.compute() assert array_equal(dask_res, z.compute(scheduler=mars_scheduler)) assert array_equal(dask_res, convert_dask_collection(z).execute().fetch())
def test_mul_ndarray_variable_forward(self): x0 = np.array([1, 2, 3]) x1 = Variable(np.array([1, 2, 3])) y = x0 * x1 res = y.data expected = np.array([1, 4, 9]) self.assertTrue(array_equal(res, expected))
def test_score_pairs_warning(estimator, build_dataset): """Tests that score_pairs returns a FutureWarning regarding deprecation. Also that score_pairs and pair_distance have the same behaviour""" input_data, labels, _, X = build_dataset() model = clone(estimator) set_random_state(model) # We fit the metric learner on it and then we call score_pairs on some # points model.fit(*remove_y(model, input_data, labels)) msg = ("score_pairs will be deprecated in release 0.7.0. " "Use pair_score to compute similarity scores, or " "pair_distances to compute distances.") with pytest.warns(FutureWarning) as raised_warning: score = model.score_pairs([[X[0], X[1]], ]) dist = model.pair_distance([[X[0], X[1]], ]) assert array_equal(score, dist) assert any([str(warning.message) == msg for warning in raised_warning])
def logisticRegression(trainData, trainLabels, testData, testLabels): #adjust the data, adding the 'free parameter' to the train data trainDataWithFreeParam = hstack((trainData.copy(), ones(trainData.shape[0])[:,newaxis])) testDataWithFreeParam = hstack((testData.copy(), ones(testData.shape[0])[:,newaxis])) alpha = 10 oldW = zeros(trainDataWithFreeParam.shape[1]) newW = ones(trainDataWithFreeParam.shape[1]) iteration = 0 trainDataWithFreeParamTranspose = transpose(trainDataWithFreeParam) alphaI = alpha * identity(oldW.shape[0]) while not array_equal(oldW, newW): if iteration == 100: break oldW = newW.copy() yVect = yVector(oldW, trainDataWithFreeParam) r = R(yVect) firstTerm = inv(alphaI + dot(dot(trainDataWithFreeParamTranspose, r), trainDataWithFreeParam)) secondTerm = dot(trainDataWithFreeParamTranspose, (yVect-trainLabels)) + alpha * oldW newW = oldW - dot(firstTerm, secondTerm) iteration += 1 #see how well we did numCorrect = 0 for x,t in izip(testDataWithFreeParam, testLabels): if yScalar(newW, x) >= 0.5: if t == 1: numCorrect += 1 else: if t == 0: numCorrect += 1 return float(numCorrect) / float(len(testLabels))
def simulate_transients_old(self, init_grid, max_steps): """ this method simulates the thing until an attractor is found """ if type(init_grid) == int: self.grid = self.rng.choice([0, 1], size=[init_grid, init_grid]) else: self.grid = init_grid # flag to set NaN if attractor is not found found_attractor = False self.history = np.zeros( (max_steps + 1, self.grid.shape[0], self.grid.shape[0])) for st in range(max_steps): self.history[st] = self.grid self.grid = self.step(self.grid) for hi, prev in enumerate(self.history[:st]): if array_equal(prev, self.grid): last_idx_transient = hi - 1 found_attractor = True break # exit loop if we're done with the attractor if found_attractor: end_step = st + 1 break # if we dont find the attractor the transient index should be NaN if not found_attractor: end_step = max_steps last_idx_transient = np.nan return self.history[:end_step], last_idx_transient
def test_sub_variable_ndarray_forward(self): x0 = Variable(np.array([4, 5, 6])) x1 = np.array([1, 2, 3]) result = (x0 - x1).data expected = np.array([3, 3, 3]) return self.assertTrue(array_equal(expected, result))
def test_change_sign_of_numpy_when_forward(self): x = np.array([1, 2, 3]) y = -x res = y.data expected = np.array([-1, -2, -3]) self.assertTrue(array_equal(res, expected))
def test_pow_variable_forward2(self): x = np.array([1, 2, 3]) result = (x**3).data expected = np.array([1, 8, 27]) return self.assertTrue(array_equal(result, expected))
def test_pow_variable_forward(self): x = Variable(np.array([4, 5, 6])) result = (x**2).data expected = np.array([16, 25, 36]) return self.assertTrue(array_equal(result, expected))
def test_div_ndarray_variable_forward(self): x0 = np.array([1, 2, 3]) x1 = Variable(np.array([4, 5, 6])) result = (x0 / x1).data expected = np.array([1 / 4, 2 / 5, 3 / 6]) return self.assertTrue(array_equal(result, expected))
def test_div_variable_ndarray_forward(self): x0 = Variable(np.array([4, 5, 6])) x1 = np.array([1, 2, 3]) result = (x0 / x1).data expected = np.array([4 / 1, 5 / 2, 6 / 3]) return self.assertTrue(array_equal(result, expected))
def test_ABF_properties(abfPath): abf = pyabf.ABF(abfPath) # file info assert isinstance(abf.abfDateTime, datetime.datetime) assert isinstance(abf.abfDateTimeString, str) assert isinstance(abf.abfFileComment, str) assert isinstance(abf.abfFilePath, str) assert isinstance(abf.abfID, str) assert isinstance(abf.fileGUID, str) assert isinstance(abf.protocol, str) assert isinstance(abf.protocolPath, str) # file version assert isinstance(abf.abfVersion, dict) assert isinstance(abf.abfVersion["major"], int) assert isinstance(abf.abfVersion["minor"], int) assert isinstance(abf.abfVersion["bugfix"], int) assert isinstance(abf.abfVersion["build"], int) assert isinstance(abf.abfVersionString, str) # abf creator version info assert isinstance(abf.creatorVersion["major"], int) assert isinstance(abf.creatorVersion["minor"], int) assert isinstance(abf.creatorVersion["bugfix"], int) assert isinstance(abf.creatorVersion["build"], int) assert isinstance(abf.creatorVersionString, str) # ADC names and units assert isinstance(abf.adcNames, list) for adcName in abf.adcNames: assert isinstance(adcName, str) assert isinstance(abf.adcUnits, list) for adcUnit in abf.adcUnits: assert isinstance(adcUnit, str) assert isinstance(abf.channelCount, int) assert isinstance(abf.channelList, list) # DAC names and units assert isinstance(abf.dacNames, list) for dacName in abf.dacNames: assert isinstance(dacName, str) assert isinstance(abf.dacUnits, list) for dacUnit in abf.dacUnits: assert isinstance(dacUnit, str) # data info assert (isinstance(abf.dataByteStart, int)) assert (isinstance(abf.dataPointByteSize, int)) assert (isinstance(abf.dataPointCount, int)) assert (isinstance(abf.dataPointsPerMs, int)) assert (isinstance(abf.dataRate, int)) assert (isinstance(abf.dataSecPerPoint, float)) assert (isinstance(abf.sweepCount, int)) assert (isinstance(abf.sweepLengthSec, float)) assert (isinstance(abf.sweepList, list)) assert (isinstance(abf.sweepPointCount, int)) assert (isinstance(abf.sampleRate, int)) assert (array_equal(abf.dataRate, abf.sampleRate)) # holding level assert (isinstance(abf.holdingCommand, list)) for value in abf.holdingCommand: assert isinstance(value, float) or isinstance(value, int) # data array size and shape assert isinstance(abf.data, np.ndarray) assert len(abf.data) == abf.channelCount assert len(abf.data[0]) == abf.dataPointCount/abf.channelCount # comments assert isinstance(abf.tagComments, list) assert isinstance(abf.tagSweeps, list) assert isinstance(abf.tagTimesMin, list) assert isinstance(abf.tagTimesSec, list) for i in range(len(abf.tagComments)): assert isinstance(abf.tagComments[i], str) assert isinstance(abf.tagSweeps[i], float) assert isinstance(abf.tagTimesMin[i], float) assert isinstance(abf.tagTimesSec[i], float) # raw data for channel in abf.channelList: dataY = abf.getAllYs(channel) dataX = abf.getAllXs(channel) assert isinstance(dataY, np.ndarray) assert isinstance(dataX, np.ndarray) assert len(dataY) != 0 assert len(dataX) == len(dataY) # sweeps for channel in abf.channelList: for sweep in abf.sweepList: abf.setSweep(sweep, channel) assert isinstance(abf.sweepChannel, int) assert isinstance(abf.sweepNumber, int) # time units are manually defined assert isinstance(abf.sweepUnitsX, str) assert abf.sweepUnitsX == "sec" # labels are pyabf inventions and will always be present assert isinstance(abf.sweepLabelX, str) assert isinstance(abf.sweepLabelY, str) assert isinstance(abf.sweepLabelC, str) # ADC labels are likely available for every channel if (abf.sweepLabelY is not None): assert isinstance(abf.sweepUnitsY, str) # DAC labels are likely available for every channel # but may not if there are more ADCs than DACs if (abf.sweepUnitsC is not None): assert isinstance(abf.sweepUnitsC, str) assert isinstance(abf.sweepD(0), np.ndarray)
if msg.is_meta: if msg.type == "time_signature": outfile.write("midi time signature num: {} den: {}\n".format(msg.numerator, msg.denominator)) if msg.type == "key_signature": outfile.write("midi key_signature:{}\n".format(msg.key)) if msg.type == "set_tempo": outfile.write("midi tempo: {}\n".format(msg.tempo)) if i != 0: for msg in track: if msg.is_meta: pass else: print("{}".format(msg)) note_map[msg.note-1] = 1 print(msg.note) piano_keys = np.append(piano_keys,note_map,axis=1) note_map = np.zeros(note_map.shape,dtype= np.int8) for raw in piano_keys: print(raw) if (True = array_equal(raw,)) print(piano_keys.shape) temp = np.zeros(piano_keys.shape[1]) print(temp.shape) temp[0] = msg.note # np.savetxt(outfile,piano_keys,delimiter=',',fmt='%d') # outfile.write("{}\n".format(piano_keys)) # print(piano_keys.shape) #outfile.write("{}\n".format(msg)) outfile.close()
def test_square_variable_forward(self): x = Variable(np.array([1, 2, 3])) y = F.square(x) expected = np.array([1, 4, 9]) self.assertTrue(array_equal(y.data, expected))
def test_exp_variable_forward(self): x = Variable(np.array([1, 2, 3])) y = F.exp(x) expected = np.exp(x.data) self.assertTrue(array_equal(y.data, expected))