Datasets:

xlangai

/

DS-1000

like 7

Problem: I'm using tensorflow 2.10.0. I've come across a case in which the averaging includes padded values. Given a tensor X of some shape (batch_size, ..., features), there could be zero padded features to get the same shape. How can I average the second to last dimension of X (the features) but only the non-zero entries? So, we divide by the sum by the number of non-zero entries. Example input: x = [[[[1,2,3], [2,3,4], [0,0,0]], [[1,2,3], [2,0,4], [3,4,5]], [[1,2,3], [0,0,0], [0,0,0]], [[1,2,3], [1,2,3], [0,0,0]]], [[[1,2,3], [0,1,0], [0,0,0]], [[1,2,3], [2,3,4], [0,0,0]], [[1,2,3], [0,0,0], [0,0,0]], [[1,2,3], [1,2,3], [1,2,3]]]] # Desired output y = [[[1.5 2.5 3.5] [2. 2. 4. ] [1. 2. 3. ] [1. 2. 3. ]] [[0.5 1.5 1.5] [1.5 2.5 3.5] [1. 2. 3. ] [1. 2. 3. ]]] A: <code> import tensorflow as tf example_x = [[[[1, 2, 3], [2, 3, 4], [0, 0, 0]], [[1, 2, 3], [2, 0, 4], [3, 4, 5]], [[1, 2, 3], [0, 0, 0], [0, 0, 0]], [[1, 2, 3], [1, 2, 3], [0, 0, 0]]], [[[1, 2, 3], [0, 1, 0], [0, 0, 0]], [[1, 2, 3], [2, 3, 4], [0, 0, 0]], [[1, 2, 3], [0, 0, 0], [0, 0, 0]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]]]] example_x = tf.convert_to_tensor(example_x, dtype=tf.float32) def f(x=example_x): # return the solution in this function # result = f(x) ### BEGIN SOLUTION

non_zero = tf.cast(x != 0, tf.float32) y = tf.reduce_sum(x, axis=-2) / tf.reduce_sum(non_zero, axis=-2) result = y return result

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): x = data non_zero = tf.cast(x != 0, tf.float32) y = tf.reduce_sum(x, axis=-2) / tf.reduce_sum(non_zero, axis=-2) return y def define_test_input(test_case_id): if test_case_id == 1: x = [ [ [[1, 2, 3], [2, 3, 4], [0, 0, 0]], [[1, 2, 3], [2, 0, 4], [3, 4, 5]], [[1, 2, 3], [0, 0, 0], [0, 0, 0]], [[1, 2, 3], [1, 2, 3], [0, 0, 0]], ], [ [[1, 2, 3], [0, 1, 0], [0, 0, 0]], [[1, 2, 3], [2, 3, 4], [0, 0, 0]], [[1, 2, 3], [0, 0, 0], [0, 0, 0]], [[1, 2, 3], [1, 2, 3], [1, 2, 3]], ], ] x = tf.convert_to_tensor(x, dtype=tf.float32) if test_case_id == 2: x = [ [ [[1, 2, 3], [2, 3, 4], [0, 0, 0]], [[1, 2, 3], [2, 0, 4], [3, 4, 5]], [[1, 2, 3], [0, 0, 0], [0, 0, 0]], [[1, 2, 3], [1, 2, 3], [0, 0, 0]], ], [ [[1, 2, 3], [0, 1, 0], [0, 0, 0]], [[1, 2, 3], [2, 3, 4], [0, 0, 0]], [[1, 2, 3], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [1, 2, 3], [1, 2, 3]], ], ] x = tf.convert_to_tensor(x, dtype=tf.float32) return x test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): def tensor_equal(a, b): if type(a) != type(b): return False if isinstance(a, type(tf.constant([]))) is not True: if isinstance(a, type(tf.Variable([]))) is not True: return False if a.shape != b.shape: return False if a.dtype != tf.float32: a = tf.cast(a, tf.float32) if b.dtype != tf.float32: b = tf.cast(b, tf.float32) if not tf.reduce_min(tf.cast(a == b, dtype=tf.int32)): return False return True try: assert tensor_equal(result, ans) return 1 except: return 0 exec_context = r""" import tensorflow as tf x = test_input def f(x): [insert] result = f(x) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: How would you convert this Tensorflow 1.5 code to Tensorflow 2.3.0? import tensorflow as tf try: Session = tf.Session except AttributeError: Session = tf.compat.v1.Session tf.random.set_seed(10) A = tf.random.normal([100,100]) B = tf.random.normal([100,100]) with Session() as sess: result = sess.run(tf.reduce_sum(tf.matmul(A,B))) The main problem is that the Session class has been removed in Tensorflow 2, and the version exposed in the compat.v1 layer doesn't actually appear to be compatible. When I run this code with Tensorflow 2, it now throws the exception: RuntimeError: Attempting to capture an EagerTensor without building a function. If I drop the use of Session entirely, is that still functionally equivalent? If I run: import tensorflow as tf A = tf.random.normal([100,100]) B = tf.random.normal([100,100]) with Session() as sess: print(tf.reduce_sum(tf.matmul(A,B))) it runs significantly faster (0.005sec vs 30sec) in Tensoflow 1.16 with AVX2 support, whereas stock Tensorflow 2 installed from pip (without AVX2 support) also runs a bit faster (30sec vs 60sec). Why would the use of Session slow down Tensorflow 1.16 by 6000x? A: <code> import tensorflow as tf </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

tf.random.set_seed(10) def get_values(): A = tf.random.normal([100,100]) B = tf.random.normal([100,100]) return A,B @tf.function def compute(): A,B = get_values() return tf.reduce_sum(tf.matmul(A,B)) result = compute()

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): FLAG = data return -805.02057 def define_test_input(test_case_id): if test_case_id == 1: FLAG = 114514 return FLAG test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): try: assert abs(result - ans) <= 0.02 return 1 except: return 0 exec_context = r""" import tensorflow as tf FLAG = test_input [insert].numpy() """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm using tensorflow 2.10.0. So I'm creating a tensorflow model and for the forward pass, I'm applying my forward pass method to get the scores tensor which contains the prediction scores for each class. The shape of this tensor is [100, 10]. Now, I want to get the accuracy by comparing it to y which contains the actual scores. This tensor has the shape [100]. To compare the two I'll be using torch.mean(scores == y) and I'll count how many are the same. The problem is that I need to convert the scores tensor so that each row simply contains the index of the highest value in each row. For example if the tensor looked like this, tf.Tensor( [[0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711]] ) Then I'd want it to be converted so that it looks like this. tf.Tensor([5 4 0]) How could I do that? A: <code> import tensorflow as tf a = tf.constant( [[0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711]] ) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

def g(a): return tf.argmax(a,axis=1) result = g(a.__copy__())

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): a = data return tf.argmax(a, axis=1) def define_test_input(test_case_id): if test_case_id == 1: a = tf.constant( [ [0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711], ] ) if test_case_id == 2: a = tf.constant( [ [0.3232, -0.2321, 0.2332, -0.1231, 0.2435], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435], [0.9823, -0.1321, -0.6433, 0.1231, 0.023], ] ) return a test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): def tensor_equal(a, b): if type(a) != type(b): return False if isinstance(a, type(tf.constant([]))) is not True: if isinstance(a, type(tf.Variable([]))) is not True: return False if a.shape != b.shape: return False if a.dtype != tf.float32: a = tf.cast(a, tf.float32) if b.dtype != tf.float32: b = tf.cast(b, tf.float32) if not tf.reduce_min(tf.cast(a == b, dtype=tf.int32)): return False return True try: assert tensor_equal(result, ans) return 1 except: return 0 exec_context = r""" import tensorflow as tf a = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm using tensorflow 2.10.0. So I'm creating a tensorflow model and for the forward pass, I'm applying my forward pass method to get the scores tensor which contains the prediction scores for each class. The shape of this tensor is [100, 10]. Now, I want to get the accuracy by comparing it to y which contains the actual scores. This tensor has the shape [10]. To compare the two I'll be using torch.mean(scores == y) and I'll count how many are the same. The problem is that I need to convert the scores tensor so that each row simply contains the index of the highest value in each column. For example if the tensor looked like this, tf.Tensor( [[0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711]] ) Then I'd want it to be converted so that it looks like this. tf.Tensor([2 1 0 2 1 0]) How could I do that? A: <code> import tensorflow as tf a = tf.constant( [[0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711]] ) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

def g(a): return tf.argmax(a,axis=0) result = g(a.__copy__())

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): a = data return tf.argmax(a, axis=0) def define_test_input(test_case_id): if test_case_id == 1: a = tf.constant( [ [0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711], ] ) if test_case_id == 2: a = tf.constant( [ [0.3232, -0.2321, 0.2332, -0.1231, 0.2435], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435], [0.9823, -0.1321, -0.6433, 0.1231, 0.023], ] ) return a test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): def tensor_equal(a, b): if type(a) != type(b): return False if isinstance(a, type(tf.constant([]))) is not True: if isinstance(a, type(tf.Variable([]))) is not True: return False if a.shape != b.shape: return False if a.dtype != tf.float32: a = tf.cast(a, tf.float32) if b.dtype != tf.float32: b = tf.cast(b, tf.float32) if not tf.reduce_min(tf.cast(a == b, dtype=tf.int32)): return False return True try: assert tensor_equal(result, ans) return 1 except: return 0 exec_context = r""" import tensorflow as tf a = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm using tensorflow 2.10.0. So I'm creating a tensorflow model and for the forward pass, I'm applying my forward pass method to get the scores tensor which contains the prediction scores for each class. The shape of this tensor is [100, 10]. Now, I want to get the accuracy by comparing it to y which contains the actual scores. This tensor has the shape [100]. To compare the two I'll be using torch.mean(scores == y) and I'll count how many are the same. The problem is that I need to convert the scores tensor so that each row simply contains the index of the highest value in each row. For example if the tensor looked like this, tf.Tensor( [[0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711]] ) Then I'd want it to be converted so that it looks like this. tf.Tensor([5 4 0]) How could I do that? A: <code> import tensorflow as tf example_a = tf.constant( [[0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711]] ) def f(a=example_a): # return the solution in this function # result = f(a) ### BEGIN SOLUTION

result = tf.argmax(a,axis=1) return result

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): a = data return tf.argmax(a, axis=1) def define_test_input(test_case_id): if test_case_id == 1: a = tf.constant( [ [0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711], ] ) if test_case_id == 2: a = tf.constant( [ [0.3232, -0.2321, 0.2332, -0.1231, 0.2435], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435], [0.9823, -0.1321, -0.6433, 0.1231, 0.023], ] ) return a test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): def tensor_equal(a, b): if type(a) != type(b): return False if isinstance(a, type(tf.constant([]))) is not True: if isinstance(a, type(tf.Variable([]))) is not True: return False if a.shape != b.shape: return False if a.dtype != tf.float32: a = tf.cast(a, tf.float32) if b.dtype != tf.float32: b = tf.cast(b, tf.float32) if not tf.reduce_min(tf.cast(a == b, dtype=tf.int32)): return False return True try: assert tensor_equal(result, ans) return 1 except: return 0 exec_context = r""" import tensorflow as tf a = test_input def f(a): [insert] result = f(a) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm using tensorflow 2.10.0. The problem is that I need to convert the scores tensor so that each row simply contains the index of the lowest value in each column. For example if the tensor looked like this, tf.Tensor( [[0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711]] ) Then I'd want it to be converted so that it looks like this. tf.Tensor([1 0 2 1 2 2]) How could I do that? A: <code> import tensorflow as tf a = tf.constant( [[0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711]] ) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

def g(a): return tf.argmin(a,axis=0) result = g(a.__copy__())

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): a = data return tf.argmin(a, axis=0) def define_test_input(test_case_id): if test_case_id == 1: a = tf.constant( [ [0.3232, -0.2321, 0.2332, -0.1231, 0.2435, 0.6728], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435, 0.1722], [0.9823, -0.1321, -0.6433, 0.1231, 0.023, 0.0711], ] ) if test_case_id == 2: a = tf.constant( [ [0.3232, -0.2321, 0.2332, -0.1231, 0.2435], [0.2323, -0.1231, -0.5321, -0.1452, 0.5435], [0.9823, -0.1321, -0.6433, 0.1231, 0.023], ] ) return a test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): def tensor_equal(a, b): if type(a) != type(b): return False if isinstance(a, type(tf.constant([]))) is not True: if isinstance(a, type(tf.Variable([]))) is not True: return False if a.shape != b.shape: return False if a.dtype != tf.float32: a = tf.cast(a, tf.float32) if b.dtype != tf.float32: b = tf.cast(b, tf.float32) if not tf.reduce_min(tf.cast(a == b, dtype=tf.int32)): return False return True try: assert tensor_equal(result, ans) return 1 except: return 0 exec_context = r""" import tensorflow as tf a = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm using tensorflow 2.10.0. I am trying to save my ANN model using SavedModel format. The command that I used was: model.save("my_model") It supposed to give me a folder namely "my_model" that contains all saved_model.pb, variables and asset, instead it gives me an HDF file namely my_model. I am using keras v.2.3.1 and tensorflow v.2.3.0 Here is a bit of my code: from keras import optimizers from keras import backend from keras.models import Sequential from keras.layers import Dense from keras.activations import relu,tanh,sigmoid network_layout = [] for i in range(3): network_layout.append(8) model = Sequential() #Adding input layer and first hidden layer model.add(Dense(network_layout[0], name = "Input", input_dim=inputdim, kernel_initializer='he_normal', activation=activation)) #Adding the rest of hidden layer for numneurons in network_layout[1:]: model.add(Dense(numneurons, kernel_initializer = 'he_normal', activation=activation)) #Adding the output layer model.add(Dense(outputdim, name="Output", kernel_initializer="he_normal", activation="relu")) #Compiling the model model.compile(optimizer=opt,loss='mse',metrics=['mse','mae','mape']) model.summary() #Training the model history = model.fit(x=Xtrain,y=ytrain,validation_data=(Xtest,ytest),batch_size=32,epochs=epochs) model.save('my_model') I have read the API documentation in the tensorflow website and I did what it said to use model.save("my_model") without any file extension, but I can't get it right. Your help will be very appreciated. Thanks a bunch! A: <code> import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense network_layout = [] for i in range(3): network_layout.append(8) model = Sequential() inputdim = 4 activation = 'relu' outputdim = 2 opt='rmsprop' epochs = 50 #Adding input layer and first hidden layer model.add(Dense(network_layout[0], name="Input", input_dim=inputdim, kernel_initializer='he_normal', activation=activation)) #Adding the rest of hidden layer for numneurons in network_layout[1:]: model.add(Dense(numneurons, kernel_initializer = 'he_normal', activation=activation)) #Adding the output layer model.add(Dense(outputdim, name="Output", kernel_initializer="he_normal", activation="relu")) #Compiling the model model.compile(optimizer=opt,loss='mse',metrics=['mse','mae','mape']) model.summary() #Save the model in "export/1" </code> BEGIN SOLUTION <code>

tms_model = tf.saved_model.save(model,"export/1")

import copy import tokenize, io def generate_test_case(test_case_id): def generate_ans(data): FLAG = data return 1 def define_test_input(test_case_id): if test_case_id == 1: FLAG = 114514 return FLAG test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): try: assert result == ans return 1 except: return 0 exec_context = r""" import shutil import os if os.path.exists('my_model'): shutil.rmtree('my_model') import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense FLAG = test_input network_layout = [] for i in range(3): network_layout.append(8) model = Sequential() inputdim = 4 activation = 'relu' outputdim = 2 opt='rmsprop' epochs = 50 model.add(Dense(network_layout[0], name="Input", input_dim=inputdim, kernel_initializer='he_normal', activation=activation)) for numneurons in network_layout[1:]: model.add(Dense(numneurons, kernel_initializer = 'he_normal', activation=activation)) model.add(Dense(outputdim, name="Output", kernel_initializer="he_normal", activation="relu")) model.compile(optimizer=opt,loss='mse',metrics=['mse','mae','mape']) [insert] try: assert os.path.exists("export") p = os.path.join("export", "1") assert os.path.exists(p) assert os.path.exists(os.path.join(p, "assets")) assert os.path.exists(os.path.join(p, "saved_model.pb")) p = os.path.join(p, "variables") assert os.path.exists(p) assert os.path.exists(os.path.join(p, "variables.data-00000-of-00001")) assert os.path.exists(os.path.join(p, "variables.index")) result = 1 except: result = 0 """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert "saved_model" in tokens

Problem: I'm using tensorflow 2.10.0. I would like to generate 10 random integers as a tensor in TensorFlow but I don't which command I should use. In particular, I would like to generate from a uniform random variable which takes values in {1, 2, 3, 4}. I have tried to look among the distributions included in tensorflow_probability but I didn't find it. Please set the random seed to 10 with tf.random.ser_seed(). Thanks in advance for your help. A: <code> import tensorflow as tf seed_x = 10 ### return the tensor as variable 'result' </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

def g(seed_x): tf.random.set_seed(seed_x) return tf.random.uniform(shape=(10,), minval=1, maxval=5, dtype=tf.int32) result = g(seed_x)

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): seed_x = data tf.random.set_seed(seed_x) return tf.random.uniform(shape=(10,), minval=1, maxval=5, dtype=tf.int32) def define_test_input(test_case_id): if test_case_id == 1: seed_x = 10 return seed_x test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): def tensor_equal(a, b): if type(a) != type(b): return False if isinstance(a, type(tf.constant([]))) is not True: if isinstance(a, type(tf.Variable([]))) is not True: return False if a.shape != b.shape: return False if a.dtype != tf.float32: a = tf.cast(a, tf.float32) if b.dtype != tf.float32: b = tf.cast(b, tf.float32) if not tf.reduce_min(tf.cast(a == b, dtype=tf.int32)): return False return True try: assert tensor_equal(result, ans) return 1 except: return 0 exec_context = r""" import tensorflow as tf seed_x = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm using tensorflow 2.10.0. I would like to generate 114 random integers as a tensor in TensorFlow but I don't which command I should use. In particular, I would like to generate from a uniform random variable which takes values in {2, 3, 4, 5}. I have tried to look among the distributions included in tensorflow_probability but I didn't find it. Please set the random seed to seed_x with tf.random.ser_seed(). Thanks in advance for your help. A: <code> import tensorflow as tf seed_x = 10 ### return the tensor as variable 'result' </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

def g(seed_x): tf.random.set_seed(seed_x) return tf.random.uniform(shape=(114,), minval=2, maxval=6, dtype=tf.int32) result = g(seed_x)

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): seed_x = data tf.random.set_seed(seed_x) return tf.random.uniform(shape=(114,), minval=2, maxval=6, dtype=tf.int32) def define_test_input(test_case_id): if test_case_id == 1: seed_x = 10 return seed_x test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): def tensor_equal(a, b): if type(a) != type(b): return False if isinstance(a, type(tf.constant([]))) is not True: if isinstance(a, type(tf.Variable([]))) is not True: return False if a.shape != b.shape: return False if a.dtype != tf.float32: a = tf.cast(a, tf.float32) if b.dtype != tf.float32: b = tf.cast(b, tf.float32) if not tf.reduce_min(tf.cast(a == b, dtype=tf.int32)): return False return True try: assert tensor_equal(result, ans) return 1 except: return 0 exec_context = r""" import tensorflow as tf seed_x = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm using tensorflow 2.10.0. I would like to generate 10 random integers as a tensor in TensorFlow but I don't which command I should use. In particular, I would like to generate from a uniform random variable which takes values in {1, 2, 3, 4}. I have tried to look among the distributions included in tensorflow_probability but I didn't find it. Please set the random seed to 10 with tf.random.ser_seed(). Thanks in advance for your help. A: <code> import tensorflow as tf def f(seed_x=10): # return the solution in this function # result = f(seed_x) ### BEGIN SOLUTION

tf.random.set_seed(seed_x) result = tf.random.uniform(shape=(10,), minval=1, maxval=5, dtype=tf.int32) return result

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): seed_x = data tf.random.set_seed(seed_x) return tf.random.uniform(shape=(10,), minval=1, maxval=5, dtype=tf.int32) def define_test_input(test_case_id): if test_case_id == 1: seed_x = 10 return seed_x test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): def tensor_equal(a, b): if type(a) != type(b): return False if isinstance(a, type(tf.constant([]))) is not True: if isinstance(a, type(tf.Variable([]))) is not True: return False if a.shape != b.shape: return False if a.dtype != tf.float32: a = tf.cast(a, tf.float32) if b.dtype != tf.float32: b = tf.cast(b, tf.float32) if not tf.reduce_min(tf.cast(a == b, dtype=tf.int32)): return False return True try: assert tensor_equal(result, ans) return 1 except: return 0 exec_context = r""" import tensorflow as tf seed_x = test_input def f(seed_x): [insert] result = f(seed_x) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm using tensorflow 2.10.0. I need to find which version of TensorFlow I have installed. I'm using Ubuntu 16.04 Long Term Support. A: <code> import tensorflow as tf ### output the version of tensorflow into variable 'result' </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = tf.version.VERSION

import tensorflow as tf import copy def generate_test_case(test_case_id): def generate_ans(data): FLAG = data return tf.version.VERSION def define_test_input(test_case_id): if test_case_id == 1: FLAG = 114514 return FLAG test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): try: assert result == ans return 1 except: return 0 exec_context = r""" import tensorflow as tf FLAG = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a set of data and I want to compare which line describes it best (polynomials of different orders, exponential or logarithmic). I use Python and Numpy and for polynomial fitting there is a function polyfit(). How do I fit y = Alogx + B using polyfit()? The result should be an np.array of [A, B] A: <code> import numpy as np import scipy x = np.array([1, 7, 20, 50, 79]) y = np.array([10, 19, 30, 35, 51]) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = np.polyfit(np.log(x), y, 1)

import numpy as np import copy def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: x = np.array([1, 7, 20, 50, 79]) y = np.array([10, 19, 30, 35, 51]) return x, y def generate_ans(data): _a = data x, y = _a result = np.polyfit(np.log(x), y, 1) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy x, y = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a set of data and I want to compare which line describes it best (polynomials of different orders, exponential or logarithmic). I use Python and Numpy and for polynomial fitting there is a function polyfit(). How do I fit y = A + Blogx using polyfit()? The result should be an np.array of [A, B] A: <code> import numpy as np import scipy x = np.array([1, 7, 20, 50, 79]) y = np.array([10, 19, 30, 35, 51]) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = np.polyfit(np.log(x), y, 1)[::-1]

import numpy as np import copy def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: x = np.array([1, 7, 20, 50, 79]) y = np.array([10, 19, 30, 35, 51]) return x, y def generate_ans(data): _a = data x, y = _a result = np.polyfit(np.log(x), y, 1)[::-1] return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy x, y = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a set of data and I want to compare which line describes it best (polynomials of different orders, exponential or logarithmic). I use Python and Numpy and for polynomial fitting there is a function polyfit(). But I found no such functions for exponential and logarithmic fitting. How do I fit y = A*exp(Bx) + C ? The result should be an np.array of [A, B, C]. I know that polyfit performs bad for this function, so I would like to use curve_fit to solve the problem, and it should start from initial guess p0. A: <code> import numpy as np import scipy.optimize y = np.array([1, 7, 20, 50, 79]) x = np.array([10, 19, 30, 35, 51]) p0 = (4, 0.1, 1) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = scipy.optimize.curve_fit(lambda t,a,b, c: a*np.exp(b*t) + c, x, y, p0=p0)[0]

import numpy as np import copy import scipy.optimize def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: y = np.array([1, 7, 20, 50, 79]) x = np.array([10, 19, 30, 35, 51]) p0 = (4, 0.1, 1) return x, y, p0 def generate_ans(data): _a = data x, y, p0 = _a result = scipy.optimize.curve_fit( lambda t, a, b, c: a * np.exp(b * t) + c, x, y, p0=p0 )[0] return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.optimize x, y, p0 = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I can't figure out how to do a Two-sample KS test in Scipy. After reading the documentation scipy kstest I can see how to test where a distribution is identical to standard normal distribution from scipy.stats import kstest import numpy as np x = np.random.normal(0,1,1000) test_stat = kstest(x, 'norm') #>>> test_stat #(0.021080234718821145, 0.76584491300591395) Which means that at p-value of 0.76 we can not reject the null hypothesis that the two distributions are identical. However, I want to compare two distributions and see if I can reject the null hypothesis that they are identical, something like: from scipy.stats import kstest import numpy as np x = np.random.normal(0,1,1000) z = np.random.normal(1.1,0.9, 1000) and test whether x and z are identical I tried the naive: test_stat = kstest(x, z) and got the following error: TypeError: 'numpy.ndarray' object is not callable Is there a way to do a two-sample KS test in Python? If so, how should I do it? Thank You in Advance A: <code> from scipy import stats import numpy as np np.random.seed(42) x = np.random.normal(0, 1, 1000) y = np.random.normal(0, 1, 1000) </code> statistic, p_value = ... # put solution in these variables BEGIN SOLUTION <code>

statistic, p_value = stats.ks_2samp(x, y)

import numpy as np import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(42) x = np.random.normal(0, 1, 1000) y = np.random.normal(0, 1, 1000) elif test_case_id == 2: np.random.seed(42) x = np.random.normal(0, 1, 1000) y = np.random.normal(1.1, 0.9, 1000) return x, y def generate_ans(data): _a = data x, y = _a statistic, p_value = stats.ks_2samp(x, y) return [statistic, p_value] test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" from scipy import stats import numpy as np np.random.seed(42) x, y = test_input [insert] result = [statistic, p_value] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I can't figure out how to do a Two-sample KS test in Scipy. After reading the documentation scipy kstest I can see how to test where a distribution is identical to standard normal distribution from scipy.stats import kstest import numpy as np x = np.random.normal(0,1,1000) test_stat = kstest(x, 'norm') #>>> test_stat #(0.021080234718821145, 0.76584491300591395) Which means that at p-value of 0.76 we can not reject the null hypothesis that the two distributions are identical. However, I want to compare two distributions and see if I can reject the null hypothesis that they are identical, something like: from scipy.stats import kstest import numpy as np x = np.random.normal(0,1,1000) z = np.random.normal(1.1,0.9, 1000) and test whether x and z are identical I tried the naive: test_stat = kstest(x, z) and got the following error: TypeError: 'numpy.ndarray' object is not callable Is there a way to do a two-sample KS test in Python, then test whether I can reject the null hypothesis that the two distributions are identical(result=True means able to reject, and the vice versa) based on alpha? If so, how should I do it? Thank You in Advance A: <code> from scipy import stats import numpy as np np.random.seed(42) x = np.random.normal(0, 1, 1000) y = np.random.normal(0, 1, 1000) alpha = 0.01 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

s, p = stats.ks_2samp(x, y) result = (p <= alpha)

import numpy as np import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(42) x = np.random.normal(0, 1, 1000) y = np.random.normal(0, 1, 1000) elif test_case_id == 2: np.random.seed(42) x = np.random.normal(0, 1, 1000) y = np.random.normal(1.1, 0.9, 1000) alpha = 0.01 return x, y, alpha def generate_ans(data): _a = data x, y, alpha = _a s, p = stats.ks_2samp(x, y) result = p <= alpha return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" from scipy import stats import numpy as np x, y, alpha = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: According to the SciPy documentation it is possible to minimize functions with multiple variables, yet it doesn't tell how to optimize on such functions. from scipy.optimize import minimize from math import sqrt, sin, pi, cos def f(c): return sqrt((sin(pi/2) + sin(0) + sin(c) - 2)**2 + (cos(pi/2) + cos(0) + cos(c) - 1)**2) print minimize(f, 3.14/2 + 3.14/7) The above code does try to minimize the function f, but for my task I need to minimize with respect to three variables, starting from `initial_guess`. Simply introducing a second argument and adjusting minimize accordingly yields an error (TypeError: f() takes exactly 2 arguments (1 given)). How does minimize work when minimizing with multiple variables. I need to minimize f(a,b,c)=((a+b-c)-2)**2 + ((3*a-b-c))**2 + sin(b) + cos(b) + 4. Result should be a list=[a,b,c], the parameters of minimized function. A: <code> import scipy.optimize as optimize from math import sqrt, sin, pi, cos initial_guess = [-1, 0, -3] </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

def g(params): import numpy as np a, b, c = params return ((a+b-c)-2)**2 + ((3*a-b-c))**2 + np.sin(b) + np.cos(b) + 4 res = optimize.minimize(g, initial_guess) result = res.x

import numpy as np import copy from scipy import optimize def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: a = [-1, 0, -3] return a def generate_ans(data): _a = data initial_guess = _a def g(params): a, b, c = params return ( ((a + b - c) - 2) ** 2 + ((3 * a - b - c)) ** 2 + np.sin(b) + np.cos(b) + 4 ) res = optimize.minimize(g, initial_guess) result = res.x return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): def g(params): a, b, c = params return ( ((a + b - c) - 2) ** 2 + ((3 * a - b - c)) ** 2 + np.sin(b) + np.cos(b) + 4 ) assert abs(g(result) - g(ans)) < 1e-2 return 1 exec_context = r""" import scipy.optimize as optimize from math import sqrt, sin, pi, cos initial_guess = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: How does one convert a list of Z-scores from the Z-distribution (standard normal distribution, Gaussian distribution) to left-tailed p-values? I have yet to find the magical function in Scipy's stats module to do this, but one must be there. A: <code> import numpy as np import scipy.stats z_scores = np.array([-3, -2, 0, 2, 2.5]) </code> p_values = ... # put solution in this variable BEGIN SOLUTION <code>

temp = np.array(z_scores) p_values = scipy.stats.norm.cdf(temp)

import numpy as np import copy import scipy.stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: a = np.array([-3, -2, 0, 2, 2.5]) return a def generate_ans(data): _a = data z_scores = _a temp = np.array(z_scores) p_values = scipy.stats.norm.cdf(temp) return p_values test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.stats z_scores = test_input [insert] result = p_values """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: How does one convert a list of Z-scores from the Z-distribution (standard normal distribution, Gaussian distribution) to left-tailed p-values? Original data is sampled from X ~ N(mu, sigma). I have yet to find the magical function in Scipy's stats module to do this, but one must be there. A: <code> import scipy.stats import numpy as np z_scores = [-3, -2, 0, 2, 2.5] mu = 3 sigma = 4 </code> p_values = ... # put solution in this variable BEGIN SOLUTION <code>

temp = np.array(z_scores) p_values = scipy.stats.norm.cdf(temp)

import numpy as np import pandas as pd import scipy from scipy import sparse import scipy.stats import copy import io from scipy import integrate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: z_scores = [-3, -2, 0, 2, 2.5] mu = 3 sigma = 4 return z_scores, mu, sigma def generate_ans(data): _a = data z_scores, mu, sigma = _a temp = np.array(z_scores) p_values = scipy.stats.norm.cdf(temp) return p_values test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.stats z_scores, mu, sigma = test_input [insert] result = p_values """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: How does one convert a left-tailed p-value to a z_score from the Z-distribution (standard normal distribution, Gaussian distribution)? I have yet to find the magical function in Scipy's stats module to do this, but one must be there. A: <code> import numpy as np import scipy.stats p_values = [0.1, 0.225, 0.5, 0.75, 0.925, 0.95] </code> z_scores = ... # put solution in this variable BEGIN SOLUTION <code>

z_scores = scipy.stats.norm.ppf(p_values)

import numpy as np import copy import scipy.stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: a = [0.1, 0.225, 0.5, 0.75, 0.925, 0.95] return a def generate_ans(data): _a = data p_values = _a z_scores = scipy.stats.norm.ppf(p_values) return z_scores test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.stats p_values = test_input [insert] result = z_scores """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have been trying to get the result of a lognormal distribution using Scipy. I already have the Mu and Sigma, so I don't need to do any other prep work. If I need to be more specific (and I am trying to be with my limited knowledge of stats), I would say that I am looking for the cumulative function (cdf under Scipy). The problem is that I can't figure out how to do this with just the mean and standard deviation on a scale of 0-1 (ie the answer returned should be something from 0-1). I'm also not sure which method from dist, I should be using to get the answer. I've tried reading the documentation and looking through SO, but the relevant questions (like this and this) didn't seem to provide the answers I was looking for. Here is a code sample of what I am working with. Thanks. Here mu and stddev stands for mu and sigma in probability density function of lognorm. from scipy.stats import lognorm stddev = 0.859455801705594 mu = 0.418749176686875 total = 37 dist = lognorm.cdf(total,mu,stddev) UPDATE: So after a bit of work and a little research, I got a little further. But I still am getting the wrong answer. The new code is below. According to R and Excel, the result should be .7434, but that's clearly not what is happening. Is there a logic flaw I am missing? stddev = 2.0785 mu = 1.744 x = 25 dist = lognorm([mu],loc=stddev) dist.cdf(x) # yields=0.96374596, expected=0.7434 A: <code> import numpy as np from scipy import stats stddev = 2.0785 mu = 1.744 x = 25 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = stats.lognorm(s=stddev, scale=np.exp(mu)).cdf(x)

import numpy as np import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: stddev = 2.0785 mu = 1.744 x = 25 elif test_case_id == 2: stddev = 2 mu = 1 x = 20 return x, mu, stddev def generate_ans(data): _a = data x, mu, stddev = _a result = stats.lognorm(s=stddev, scale=np.exp(mu)).cdf(x) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np from scipy import stats x, mu, stddev = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have been trying to get the arithmetic result of a lognormal distribution using Scipy. I already have the Mu and Sigma, so I don't need to do any other prep work. If I need to be more specific (and I am trying to be with my limited knowledge of stats), I would say that I am looking for the expected value and median of the distribution. The problem is that I can't figure out how to do this with just the mean and standard deviation. I'm also not sure which method from dist, I should be using to get the answer. I've tried reading the documentation and looking through SO, but the relevant questions (like this and this) didn't seem to provide the answers I was looking for. Here is a code sample of what I am working with. Thanks. Here mu and stddev stands for mu and sigma in probability density function of lognorm. from scipy.stats import lognorm stddev = 0.859455801705594 mu = 0.418749176686875 total = 37 dist = lognorm(total,mu,stddev) What should I do next? A: <code> import numpy as np from scipy import stats stddev = 2.0785 mu = 1.744 </code> expected_value, median = ... # put solution in these variables BEGIN SOLUTION <code>

expected_value = np.exp(mu + stddev ** 2 / 2) median = np.exp(mu)

import numpy as np import copy def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: stddev = 2.0785 mu = 1.744 return mu, stddev def generate_ans(data): _a = data mu, stddev = _a expected_value = np.exp(mu + stddev**2 / 2) median = np.exp(mu) return [expected_value, median] test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np from scipy import stats mu, stddev = test_input [insert] result = [expected_value, median] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have this example of matrix by matrix multiplication using numpy arrays: import numpy as np m = np.array([[1,2,3],[4,5,6],[7,8,9]]) c = np.array([0,1,2]) m * c array([[ 0, 2, 6], [ 0, 5, 12], [ 0, 8, 18]]) How can i do the same thing if m is scipy sparse CSR matrix? The result should be csr_matrix as well. This gives dimension mismatch: sp.sparse.csr_matrix(m)*sp.sparse.csr_matrix(c) A: <code> from scipy import sparse import numpy as np sa = sparse.csr_matrix(np.array([[1,2,3],[4,5,6],[7,8,9]])) sb = sparse.csr_matrix(np.array([0,1,2])) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = sa.multiply(sb)

import numpy as np import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: sa = sparse.csr_matrix(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])) sb = sparse.csr_matrix(np.array([0, 1, 2])) elif test_case_id == 2: sa = sparse.random(10, 10, density=0.2, format="csr", random_state=42) sb = sparse.random(10, 1, density=0.4, format="csr", random_state=45) return sa, sb def generate_ans(data): _a = data sa, sb = _a result = sa.multiply(sb) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == sparse.csr.csr_matrix assert len(sparse.find(result != ans)[0]) == 0 return 1 exec_context = r""" from scipy import sparse import numpy as np sa, sb = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have this example of matrix by matrix multiplication using numpy arrays: import numpy as np m = np.array([[1,2,3],[4,5,6],[7,8,9]]) c = np.array([0,1,2]) m * c array([[ 0, 2, 6], [ 0, 5, 12], [ 0, 8, 18]]) How can i do the same thing if m is scipy sparse CSR matrix? The result should be csr_matrix as well. This gives dimension mismatch: sp.sparse.csr_matrix(m)*sp.sparse.csr_matrix(c) A: <code> from scipy import sparse import numpy as np example_sA = sparse.csr_matrix(np.array([[1,2,3],[4,5,6],[7,8,9]])) example_sB = sparse.csr_matrix(np.array([0,1,2])) def f(sA = example_sA, sB = example_sB): # return the solution in this function # result = f(sA, sB) ### BEGIN SOLUTION

result = sA.multiply(sB) return result

import numpy as np import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: sa = sparse.csr_matrix(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])) sb = sparse.csr_matrix(np.array([0, 1, 2])) elif test_case_id == 2: sa = sparse.random(10, 10, density=0.2, format="csr", random_state=42) sb = sparse.random(10, 1, density=0.4, format="csr", random_state=45) return sa, sb def generate_ans(data): _a = data sA, sB = _a result = sA.multiply(sB) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == sparse.csr.csr_matrix assert len(sparse.find(result != ans)[0]) == 0 return 1 exec_context = r""" from scipy import sparse import numpy as np sA, sB = test_input def f(sA, sB): [insert] result = f(sA, sB) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have some data that comes in the form (x, y, z, V) where x,y,z are distances, and V is the moisture. I read a lot on StackOverflow about interpolation by python like this and this valuable posts, but all of them were about regular grids of x, y, z. i.e. every value of x contributes equally with every point of y, and every point of z. On the other hand, my points came from 3D finite element grid (as below), where the grid is not regular. The two mentioned posts 1 and 2, defined each of x, y, z as a separate numpy array then they used something like cartcoord = zip(x, y) then scipy.interpolate.LinearNDInterpolator(cartcoord, z) (in a 3D example). I can not do the same as my 3D grid is not regular, thus not each point has a contribution to other points, so if when I repeated these approaches I found many null values, and I got many errors. Here are 10 sample points in the form of [x, y, z, V] data = [[27.827, 18.530, -30.417, 0.205] , [24.002, 17.759, -24.782, 0.197] , [22.145, 13.687, -33.282, 0.204] , [17.627, 18.224, -25.197, 0.197] , [29.018, 18.841, -38.761, 0.212] , [24.834, 20.538, -33.012, 0.208] , [26.232, 22.327, -27.735, 0.204] , [23.017, 23.037, -29.230, 0.205] , [28.761, 21.565, -31.586, 0.211] , [26.263, 23.686, -32.766, 0.215]] I want to get the interpolated value V of the point (25, 20, -30). How can I get it? A: <code> import numpy as np import scipy.interpolate points = np.array([ [ 27.827, 18.53 , -30.417], [ 24.002, 17.759, -24.782], [ 22.145, 13.687, -33.282], [ 17.627, 18.224, -25.197], [ 29.018, 18.841, -38.761], [ 24.834, 20.538, -33.012], [ 26.232, 22.327, -27.735], [ 23.017, 23.037, -29.23 ], [ 28.761, 21.565, -31.586], [ 26.263, 23.686, -32.766]]) V = np.array([0.205, 0.197, 0.204, 0.197, 0.212, 0.208, 0.204, 0.205, 0.211, 0.215]) request = np.array([[25, 20, -30]]) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = scipy.interpolate.griddata(points, V, request)

import numpy as np import copy import scipy.interpolate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: points = np.array( [ [27.827, 18.53, -30.417], [24.002, 17.759, -24.782], [22.145, 13.687, -33.282], [17.627, 18.224, -25.197], [29.018, 18.841, -38.761], [24.834, 20.538, -33.012], [26.232, 22.327, -27.735], [23.017, 23.037, -29.23], [28.761, 21.565, -31.586], [26.263, 23.686, -32.766], ] ) values = np.array( [0.205, 0.197, 0.204, 0.197, 0.212, 0.208, 0.204, 0.205, 0.211, 0.215] ) request = np.array([[25, 20, -30]]) return points, values, request def generate_ans(data): _a = data points, V, request = _a result = scipy.interpolate.griddata(points, V, request) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans, atol=1e-3) return 1 exec_context = r""" import numpy as np import scipy.interpolate points, V, request = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have some data that comes in the form (x, y, z, V) where x,y,z are distances, and V is the moisture. I read a lot on StackOverflow about interpolation by python like this and this valuable posts, but all of them were about regular grids of x, y, z. i.e. every value of x contributes equally with every point of y, and every point of z. On the other hand, my points came from 3D finite element grid (as below), where the grid is not regular. The two mentioned posts 1 and 2, defined each of x, y, z as a separate numpy array then they used something like cartcoord = zip(x, y) then scipy.interpolate.LinearNDInterpolator(cartcoord, z) (in a 3D example). I can not do the same as my 3D grid is not regular, thus not each point has a contribution to other points, so if when I repeated these approaches I found many null values, and I got many errors. Here are 10 sample points in the form of [x, y, z, V] data = [[27.827, 18.530, -30.417, 0.205] , [24.002, 17.759, -24.782, 0.197] , [22.145, 13.687, -33.282, 0.204] , [17.627, 18.224, -25.197, 0.197] , [29.018, 18.841, -38.761, 0.212] , [24.834, 20.538, -33.012, 0.208] , [26.232, 22.327, -27.735, 0.204] , [23.017, 23.037, -29.230, 0.205] , [28.761, 21.565, -31.586, 0.211] , [26.263, 23.686, -32.766, 0.215]] I want to get the interpolated value V of the point (25, 20, -30) and (27, 20, -32) as a list. How can I get it? A: <code> import numpy as np import scipy.interpolate points = np.array([ [ 27.827, 18.53 , -30.417], [ 24.002, 17.759, -24.782], [ 22.145, 13.687, -33.282], [ 17.627, 18.224, -25.197], [ 29.018, 18.841, -38.761], [ 24.834, 20.538, -33.012], [ 26.232, 22.327, -27.735], [ 23.017, 23.037, -29.23 ], [ 28.761, 21.565, -31.586], [ 26.263, 23.686, -32.766]]) V = np.array([0.205, 0.197, 0.204, 0.197, 0.212, 0.208, 0.204, 0.205, 0.211, 0.215]) request = np.array([[25, 20, -30], [27, 20, -32]]) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = scipy.interpolate.griddata(points, V, request).tolist()

import numpy as np import copy import scipy.interpolate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: points = np.array( [ [27.827, 18.53, -30.417], [24.002, 17.759, -24.782], [22.145, 13.687, -33.282], [17.627, 18.224, -25.197], [29.018, 18.841, -38.761], [24.834, 20.538, -33.012], [26.232, 22.327, -27.735], [23.017, 23.037, -29.23], [28.761, 21.565, -31.586], [26.263, 23.686, -32.766], ] ) values = np.array( [0.205, 0.197, 0.204, 0.197, 0.212, 0.208, 0.204, 0.205, 0.211, 0.215] ) request = np.array([[25, 20, -30], [27, 20, -32]]) return points, values, request def generate_ans(data): _a = data points, V, request = _a result = scipy.interpolate.griddata(points, V, request).tolist() return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans, atol=1e-3) return 1 exec_context = r""" import numpy as np import scipy.interpolate points, V, request = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a numpy array for an image that I read in from a FITS file. I rotated it by N degrees using scipy.ndimage.interpolation.rotate. Then I want to figure out where some point (x,y) in the original non-rotated frame ends up in the rotated image -- i.e., what are the rotated frame coordinates (x',y')? This should be a very simple rotation matrix problem but if I do the usual mathematical or programming based rotation equations, the new (x',y') do not end up where they originally were. I suspect this has something to do with needing a translation matrix as well because the scipy rotate function is based on the origin (0,0) rather than the actual center of the image array. Can someone please tell me how to get the rotated frame (x',y')? As an example, you could use from scipy import misc from scipy.ndimage import rotate data_orig = misc.face() data_rot = rotate(data_orig,66) # data array x0,y0 = 580,300 # left eye; (xrot,yrot) should point there A: <code> from scipy import misc from scipy.ndimage import rotate import numpy as np data_orig = misc.face() x0,y0 = 580,300 # left eye; (xrot,yrot) should point there angle = np.random.randint(1, 360) </code> data_rot, xrot, yrot = ... # put solution in these variables BEGIN SOLUTION <code>

def rot_ans(image, xy, angle): im_rot = rotate(image,angle) org_center = (np.array(image.shape[:2][::-1])-1)/2. rot_center = (np.array(im_rot.shape[:2][::-1])-1)/2. org = xy-org_center a = np.deg2rad(angle) new = np.array([org[0]*np.cos(a) + org[1]*np.sin(a), -org[0]*np.sin(a) + org[1]*np.cos(a) ]) return im_rot, new+rot_center data_rot, (xrot, yrot) =rot_ans(data_orig, np.array([x0, y0]), angle)

import numpy as np import copy from scipy import misc from scipy.ndimage import rotate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: data_orig = misc.face() x0, y0 = 580, 300 # left eye; (xrot,yrot) should point there np.random.seed(42) angle = np.random.randint(1, 360) return data_orig, x0, y0, angle def generate_ans(data): _a = data data_orig, x0, y0, angle = _a def rot_ans(image, xy, angle): im_rot = rotate(image, angle) org_center = (np.array(image.shape[:2][::-1]) - 1) / 2.0 rot_center = (np.array(im_rot.shape[:2][::-1]) - 1) / 2.0 org = xy - org_center a = np.deg2rad(angle) new = np.array( [ org[0] * np.cos(a) + org[1] * np.sin(a), -org[0] * np.sin(a) + org[1] * np.cos(a), ] ) return im_rot, new + rot_center data_rot, (xrot, yrot) = rot_ans(data_orig, np.array([x0, y0]), angle) return [data_rot, (xrot, yrot)] test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): res, (x1, y1) = result answer, (x_ans, y_ans) = ans assert np.allclose((x1, y1), (x_ans, y_ans)) assert np.allclose(res, answer) return 1 exec_context = r""" from scipy import misc from scipy.ndimage import rotate import numpy as np data_orig, x0, y0, angle = test_input [insert] result = [data_rot, (xrot, yrot)] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: How can I extract the main diagonal(1-d array) of a sparse matrix? The matrix is created in scipy.sparse. I want equivalent of np.diagonal(), but for sparse matrix. A: <code> import numpy as np from scipy.sparse import csr_matrix arr = np.random.rand(4, 4) M = csr_matrix(arr) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = M.A.diagonal(0)

import numpy as np import copy from scipy.sparse import csr_matrix def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: arr = np.array( [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] ) elif test_case_id == 2: np.random.seed(42) arr = np.random.rand(6, 6) return arr def generate_ans(data): _a = data arr = _a M = csr_matrix(arr) result = M.A.diagonal(0) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np from scipy.sparse import csr_matrix arr = test_input M = csr_matrix(arr) [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I simulate times in the range 0 to T according to a Poisson process. The inter-event times are exponential and we know that the distribution of the times should be uniform in the range 0 to T. def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while (times[-1] < T): times.append(time+times[-1]) time = random.expovariate(rate) return times[1:] I would simply like to run one of the tests for uniformity, for example the Kolmogorov-Smirnov test. I can't work out how to do this in scipy however. If I do import random from scipy.stats import kstest times = poisson_simul(1, 100) print kstest(times, "uniform") it is not right . It gives me (1.0, 0.0) I just want to test the hypothesis that the points are uniformly chosen from the range 0 to T. How do you do this in scipy? The result should be KStest result. A: <code> from scipy import stats import random import numpy as np def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while (times[-1] < T): times.append(time+times[-1]) time = random.expovariate(rate) return times[1:] rate = 1.0 T = 100.0 times = poisson_simul(rate, T) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = stats.kstest(times, stats.uniform(loc=0, scale=T).cdf)

import numpy as np import random import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while times[-1] < T: times.append(time + times[-1]) time = random.expovariate(rate) return times[1:] random.seed(42) rate = 1.0 T = 100.0 times = poisson_simul(rate, T) return rate, T, times def generate_ans(data): _a = data rate, T, times = _a result = stats.kstest(times, stats.uniform(loc=0, scale=T).cdf) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" from scipy import stats import random import numpy as np def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while (times[-1] < T): times.append(time+times[-1]) time = random.expovariate(rate) return times[1:] rate, T, times = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I simulate times in the range 0 to T according to a Poisson process. The inter-event times are exponential and we know that the distribution of the times should be uniform in the range 0 to T. def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while (times[-1] < T): times.append(time+times[-1]) time = random.expovariate(rate) return times[1:] I would simply like to run one of the tests for uniformity, for example the Kolmogorov-Smirnov test. I can't work out how to do this in scipy however. If I do import random from scipy.stats import kstest times = poisson_simul(1, 100) print kstest(times, "uniform") it is not right . It gives me (1.0, 0.0) I just want to test the hypothesis that the points are uniformly chosen from the range 0 to T. How do you do this in scipy? The result should be KStest result. A: <code> from scipy import stats import random import numpy as np def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while (times[-1] < T): times.append(time+times[-1]) time = random.expovariate(rate) return times[1:] example_rate = 1.0 example_T = 100.0 example_times = poisson_simul(example_rate, example_T) def f(times = example_times, rate = example_rate, T = example_T): # return the solution in this function # result = f(times, rate, T) ### BEGIN SOLUTION

result = stats.kstest(times, stats.uniform(loc=0, scale=T).cdf) return result

import numpy as np import random import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while times[-1] < T: times.append(time + times[-1]) time = random.expovariate(rate) return times[1:] random.seed(42) rate = 1.0 T = 100.0 times = poisson_simul(rate, T) return rate, T, times def generate_ans(data): _a = data rate, T, times = _a result = stats.kstest(times, stats.uniform(loc=0, scale=T).cdf) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" from scipy import stats import random import numpy as np def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while (times[-1] < T): times.append(time+times[-1]) time = random.expovariate(rate) return times[1:] rate, T, times = test_input def f(times, rate, T): [insert] result = f(times, rate, T) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I simulate times in the range 0 to T according to a Poisson process. The inter-event times are exponential and we know that the distribution of the times should be uniform in the range 0 to T. def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while (times[-1] < T): times.append(time+times[-1]) time = random.expovariate(rate) return times[1:] I would simply like to run one of the tests for uniformity, for example the Kolmogorov-Smirnov test. I can't work out how to do this in scipy however. If I do import random from scipy.stats import kstest times = poisson_simul(1, 100) print kstest(times, "uniform") it is not right . It gives me (1.0, 0.0) I just want to test the hypothesis that the points are uniformly chosen from the range 0 to T. How do you do this in scipy? Another question is how to interpret the result? What I want is just `True` for unifomity or `False` vice versa. Suppose I want a confidence level of 95%. A: <code> from scipy import stats import random import numpy as np def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while (times[-1] < T): times.append(time+times[-1]) time = random.expovariate(rate) return times[1:] rate = 1.0 T = 100.0 times = poisson_simul(rate, T) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

res= stats.kstest(times, stats.uniform(loc=0, scale=T).cdf) if res[1] < 0.05: result = False else: result = True

import numpy as np import random import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while times[-1] < T: times.append(time + times[-1]) time = random.expovariate(rate) return times[1:] if test_case_id == 1: random.seed(42) rate = 1 T = 100 times = poisson_simul(rate, T) elif test_case_id == 2: random.seed(45) rate = 1 T = 500 times = poisson_simul(rate, T) return rate, T, times def generate_ans(data): _a = data rate, T, times = _a res = stats.kstest(times, stats.uniform(loc=0, scale=T).cdf) if res[1] < 0.05: result = False else: result = True return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" from scipy import stats import random import numpy as np def poisson_simul(rate, T): time = random.expovariate(rate) times = [0] while (times[-1] < T): times.append(time+times[-1]) time = random.expovariate(rate) return times[1:] rate, T, times = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have two csr_matrix, c1, c2. I want a new matrix Feature = [c1, c2]. But if I directly concatenate them horizontally this way, there's an error that says the matrix Feature is a list. How can I achieve the matrix concatenation and still get the same type of matrix, i.e. a csr_matrix? And it doesn't work if I do this after the concatenation: Feature = csr_matrix(Feature) It gives the error: Traceback (most recent call last): File "yelpfilter.py", line 91, in <module> Feature = csr_matrix(Feature) File "c:\python27\lib\site-packages\scipy\sparse\compressed.py", line 66, in __init__ self._set_self( self.__class__(coo_matrix(arg1, dtype=dtype)) ) File "c:\python27\lib\site-packages\scipy\sparse\coo.py", line 185, in __init__ self.row, self.col = M.nonzero() TypeError: __nonzero__ should return bool or int, returned numpy.bool_ A: <code> from scipy import sparse c1 = sparse.csr_matrix([[0, 0, 1, 0], [2, 0, 0, 0], [0, 0, 0, 0]]) c2 = sparse.csr_matrix([[0, 3, 4, 0], [0, 0, 0, 5], [6, 7, 0, 8]]) </code> Feature = ... # put solution in this variable BEGIN SOLUTION <code>

Feature = sparse.hstack((c1, c2)).tocsr()

import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: c1 = sparse.csr_matrix([[0, 0, 1, 0], [2, 0, 0, 0], [0, 0, 0, 0]]) c2 = sparse.csr_matrix([[0, 3, 4, 0], [0, 0, 0, 5], [6, 7, 0, 8]]) return c1, c2 def generate_ans(data): _a = data c1, c2 = _a Feature = sparse.hstack((c1, c2)).tocsr() return Feature test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == sparse.csr_matrix assert len(sparse.find(ans != result)[0]) == 0 return 1 exec_context = r""" from scipy import sparse c1, c2 = test_input [insert] result = Feature """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have two csr_matrix, c1 and c2. I want a new sparse matrix Feature = [c1, c2], that is, to stack c1 and c2 horizontally to get a new sparse matrix. To make use of sparse matrix's memory efficiency, I don't want results as dense arrays. But if I directly concatenate them this way, there's an error that says the matrix Feature is a list. And if I try this: Feature = csr_matrix(Feature) It gives the error: Traceback (most recent call last): File "yelpfilter.py", line 91, in <module> Feature = csr_matrix(Feature) File "c:\python27\lib\site-packages\scipy\sparse\compressed.py", line 66, in __init__ self._set_self( self.__class__(coo_matrix(arg1, dtype=dtype)) ) File "c:\python27\lib\site-packages\scipy\sparse\coo.py", line 185, in __init__ self.row, self.col = M.nonzero() TypeError: __nonzero__ should return bool or int, returned numpy.bool_ Any help would be appreciated! A: <code> from scipy import sparse c1 = sparse.csr_matrix([[0, 0, 1, 0], [2, 0, 0, 0], [0, 0, 0, 0]]) c2 = sparse.csr_matrix([[0, 3, 4, 0], [0, 0, 0, 5], [6, 7, 0, 8]]) </code> Feature = ... # put solution in this variable BEGIN SOLUTION <code>

Feature = sparse.hstack((c1, c2)).tocsr()

import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: c1 = sparse.csr_matrix([[0, 0, 1, 0], [2, 0, 0, 0], [0, 0, 0, 0]]) c2 = sparse.csr_matrix([[0, 3, 4, 0], [0, 0, 0, 5], [6, 7, 0, 8]]) return c1, c2 def generate_ans(data): _a = data c1, c2 = _a Feature = sparse.hstack((c1, c2)).tocsr() return Feature test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == sparse.csr_matrix assert len(sparse.find(ans != result)[0]) == 0 return 1 exec_context = r""" from scipy import sparse c1, c2 = test_input [insert] result = Feature """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have two csr_matrix, c1 and c2. I want a new matrix Feature = [c1 c2]. That is, I want to concatenate c1 and c2 in vertical direction. But I don't know how to represent the concatenation or how to form the format. How can I achieve the matrix concatenation and still get the same type of matrix, i.e. a csr_matrix? Any help would be appreciated. A: <code> from scipy import sparse c1 = sparse.csr_matrix([[0, 0, 1, 0], [2, 0, 0, 0], [0, 0, 0, 0]]) c2 = sparse.csr_matrix([[0, 3, 4, 0], [0, 0, 0, 5], [6, 7, 0, 8]]) </code> Feature = ... # put solution in this variable BEGIN SOLUTION <code>

Feature = sparse.vstack((c1, c2))

import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: c1 = sparse.csr_matrix([[0, 0, 1, 0], [2, 0, 0, 0], [0, 0, 0, 0]]) c2 = sparse.csr_matrix([[0, 3, 4, 0], [0, 0, 0, 5], [6, 7, 0, 8]]) return c1, c2 def generate_ans(data): _a = data c1, c2 = _a Feature = sparse.vstack((c1, c2)) return Feature test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == sparse.csr_matrix assert len(sparse.find(ans != result)[0]) == 0 return 1 exec_context = r""" from scipy import sparse c1, c2 = test_input [insert] result = Feature """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: Given two sets of points in n-dimensional space, how can one map points from one set to the other, such that each point is only used once and the total euclidean distance between the pairs of points is minimized? For example, import matplotlib.pyplot as plt import numpy as np # create six points in 2d space; the first three belong to set "A" and the # second three belong to set "B" x = [1, 2, 3, 1.8, 1.9, 3.4] y = [2, 3, 1, 2.6, 3.4, 0.4] colors = ['red'] * 3 + ['blue'] * 3 plt.scatter(x, y, c=colors) plt.show() So in the example above, the goal would be to map each red point to a blue point such that each blue point is only used once and the sum of the distances between points is minimized. The application I have in mind involves a fairly small number of datapoints in 3-dimensional space, so the brute force approach might be fine, but I thought I would check to see if anyone knows of a more efficient or elegant solution first. The result should be an assignment of points in second set to corresponding elements in the first set. For example, a matching solution is Points1 <-> Points2 0 --- 2 1 --- 0 2 --- 1 and the result is [2, 0, 1] A: <code> import numpy as np import scipy.spatial import scipy.optimize points1 = np.array([(x, y) for x in np.linspace(-1,1,7) for y in np.linspace(-1,1,7)]) N = points1.shape[0] points2 = 2*np.random.rand(N,2)-1 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

C = scipy.spatial.distance.cdist(points1, points2) _, result = scipy.optimize.linear_sum_assignment(C)

import numpy as np import copy import scipy.spatial import scipy.optimize def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(100) points1 = np.array( [(x, y) for x in np.linspace(-1, 1, 7) for y in np.linspace(-1, 1, 7)] ) N = points1.shape[0] points2 = 2 * np.random.rand(N, 2) - 1 return points1, N, points2 def generate_ans(data): _a = data points1, N, points2 = _a C = scipy.spatial.distance.cdist(points1, points2) _, result = scipy.optimize.linear_sum_assignment(C) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np import scipy.spatial import scipy.optimize np.random.seed(100) points1, N, points2 = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: Given two sets of points in n-dimensional space, how can one map points from one set to the other, such that each point is only used once and the total Manhattan distance between the pairs of points is minimized? For example, import matplotlib.pyplot as plt import numpy as np # create six points in 2d space; the first three belong to set "A" and the # second three belong to set "B" x = [1, 2, 3, 1.8, 1.9, 3.4] y = [2, 3, 1, 2.6, 3.4, 0.4] colors = ['red'] * 3 + ['blue'] * 3 plt.scatter(x, y, c=colors) plt.show() So in the example above, the goal would be to map each red point to a blue point such that each blue point is only used once and the sum of the distances between points is minimized. The application I have in mind involves a fairly small number of datapoints in 3-dimensional space, so the brute force approach might be fine, but I thought I would check to see if anyone knows of a more efficient or elegant solution first. The result should be an assignment of points in second set to corresponding elements in the first set. For example, a matching solution is Points1 <-> Points2 0 --- 2 1 --- 0 2 --- 1 and the result is [2, 0, 1] A: <code> import numpy as np import scipy.spatial import scipy.optimize points1 = np.array([(x, y) for x in np.linspace(-1,1,7) for y in np.linspace(-1,1,7)]) N = points1.shape[0] points2 = 2*np.random.rand(N,2)-1 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

C = scipy.spatial.distance.cdist(points1, points2, metric='minkowski', p=1) _, result = scipy.optimize.linear_sum_assignment(C)

import numpy as np import copy import scipy.spatial import scipy.optimize def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(100) points1 = np.array( [(x, y) for x in np.linspace(-1, 1, 7) for y in np.linspace(-1, 1, 7)] ) N = points1.shape[0] points2 = 2 * np.random.rand(N, 2) - 1 return points1, N, points2 def generate_ans(data): _a = data points1, N, points2 = _a C = scipy.spatial.distance.cdist(points1, points2, metric="minkowski", p=1) _, result = scipy.optimize.linear_sum_assignment(C) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np import scipy.spatial import scipy.optimize points1, N, points2 = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I want to remove diagonal elements from a sparse matrix. Since the matrix is sparse, these elements shouldn't be stored once removed. Scipy provides a method to set diagonal elements values: setdiag If I try it using lil_matrix, it works: >>> a = np.ones((2,2)) >>> c = lil_matrix(a) >>> c.setdiag(0) >>> c <2x2 sparse matrix of type '<type 'numpy.float64'>' with 2 stored elements in LInked List format> However with csr_matrix, it seems diagonal elements are not removed from storage: >>> b = csr_matrix(a) >>> b <2x2 sparse matrix of type '<type 'numpy.float64'>' with 4 stored elements in Compressed Sparse Row format> >>> b.setdiag(0) >>> b <2x2 sparse matrix of type '<type 'numpy.float64'>' with 4 stored elements in Compressed Sparse Row format> >>> b.toarray() array([[ 0., 1.], [ 1., 0.]]) Through a dense array, we have of course: >>> csr_matrix(b.toarray()) <2x2 sparse matrix of type '<type 'numpy.float64'>' with 2 stored elements in Compressed Sparse Row format> Is that intended? If so, is it due to the compressed format of csr matrices? Is there any workaround else than going from sparse to dense to sparse again? A: <code> from scipy import sparse import numpy as np a = np.ones((2, 2)) b = sparse.csr_matrix(a) </code> b = ... # put solution in this variable BEGIN SOLUTION <code>

b = sparse.csr_matrix(a) b.setdiag(0) b.eliminate_zeros()

import numpy as np import copy import tokenize, io from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: a = np.ones((2, 2)) b = sparse.csr_matrix(a) elif test_case_id == 2: a = [] b = sparse.csr_matrix([]) return a, b def generate_ans(data): _a = data a, b = _a b = sparse.csr_matrix(a) b.setdiag(0) b.eliminate_zeros() return b test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == type(ans) assert len(sparse.find(result != ans)[0]) == 0 assert result.nnz == ans.nnz return 1 exec_context = r""" from scipy import sparse import numpy as np a, b = test_input [insert] result = b """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert ( "toarray" not in tokens and "array" not in tokens and "todense" not in tokens and "A" not in tokens )

Problem: I am working with a 2D numpy array made of 512x512=262144 values. Such values are of float type and range from 0.0 to 1.0. The array has an X,Y coordinate system which originates in the top left corner: thus, position (0,0) is in the top left corner, while position (512,512) is in the bottom right corner. This is how the 2D array looks like (just an excerpt): X,Y,Value 0,0,0.482 0,1,0.49 0,2,0.496 0,3,0.495 0,4,0.49 0,5,0.489 0,6,0.5 0,7,0.504 0,8,0.494 0,9,0.485 I would like to be able to: Count the number of regions of cells which value exceeds a given threshold, i.e. 0.75; Note: If two elements touch horizontally, vertically or diagnoally, they belong to one region. A: <code> import numpy as np from scipy import ndimage np.random.seed(10) gen = np.random.RandomState(0) img = gen.poisson(2, size=(512, 512)) img = ndimage.gaussian_filter(img.astype(np.double), (30, 30)) img -= img.min() img /= img.max() threshold = 0.75 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

blobs = img > threshold labels, result = ndimage.label(blobs)

import numpy as np import copy from scipy import ndimage def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) gen = np.random.RandomState(0) img = gen.poisson(2, size=(512, 512)) img = ndimage.gaussian_filter(img.astype(np.double), (30, 30)) img -= img.min() img /= img.max() return img def generate_ans(data): _a = data img = _a threshold = 0.75 blobs = img > threshold labels, result = ndimage.label(blobs) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np from scipy import ndimage img = test_input threshold = 0.75 [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I am working with a 2D numpy array made of 512x512=262144 values. Such values are of float type and range from 0.0 to 1.0. The array has an X,Y coordinate system which originates in the top left corner: thus, position (0,0) is in the top left corner, while position (512,512) is in the bottom right corner. This is how the 2D array looks like (just an excerpt): X,Y,Value 0,0,0.482 0,1,0.49 0,2,0.496 0,3,0.495 0,4,0.49 0,5,0.489 0,6,0.5 0,7,0.504 0,8,0.494 0,9,0.485 I would like to be able to: Count the number of regions of cells which value below a given threshold, i.e. 0.75; Note: If two elements touch horizontally, vertically or diagnoally, they belong to one region. A: <code> import numpy as np from scipy import ndimage np.random.seed(10) gen = np.random.RandomState(0) img = gen.poisson(2, size=(512, 512)) img = ndimage.gaussian_filter(img.astype(np.double), (30, 30)) img -= img.min() img /= img.max() threshold = 0.75 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

blobs = img < threshold labels, result = ndimage.label(blobs)

import numpy as np import copy from scipy import ndimage def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) gen = np.random.RandomState(0) img = gen.poisson(2, size=(512, 512)) img = ndimage.gaussian_filter(img.astype(np.double), (30, 30)) img -= img.min() img /= img.max() return img def generate_ans(data): _a = data img = _a threshold = 0.75 blobs = img < threshold labels, result = ndimage.label(blobs) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np from scipy import ndimage img = test_input threshold = 0.75 [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I am working with a 2D numpy array made of 512x512=262144 values. Such values are of float type and range from 0.0 to 1.0. The array has an X,Y coordinate system which originates in the top left corner: thus, position (0,0) is in the top left corner, while position (512,512) is in the bottom right corner. This is how the 2D array looks like (just an excerpt): X,Y,Value 0,0,0.482 0,1,0.49 0,2,0.496 0,3,0.495 0,4,0.49 0,5,0.489 0,6,0.5 0,7,0.504 0,8,0.494 0,9,0.485 I would like to be able to: Count the number of regions of cells which value exceeds a given threshold, i.e. 0.75; Note: If two elements touch horizontally, vertically or diagnoally, they belong to one region. A: <code> import numpy as np from scipy import ndimage np.random.seed(10) gen = np.random.RandomState(0) img = gen.poisson(2, size=(512, 512)) img = ndimage.gaussian_filter(img.astype(np.double), (30, 30)) img -= img.min() example_img /= img.max() def f(img = example_img): threshold = 0.75 # return the solution in this function # result = f(img) ### BEGIN SOLUTION

blobs = img > threshold labels, result = ndimage.label(blobs) return result

import numpy as np import copy from scipy import ndimage def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) gen = np.random.RandomState(0) img = gen.poisson(2, size=(512, 512)) img = ndimage.gaussian_filter(img.astype(np.double), (30, 30)) img -= img.min() img /= img.max() return img def generate_ans(data): _a = data img = _a threshold = 0.75 blobs = img > threshold labels, result = ndimage.label(blobs) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np from scipy import ndimage def f(img): threshold = 0.75 [insert] img = test_input result = f(img) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I am working with a 2D numpy array made of 512x512=262144 values. Such values are of float type and range from 0.0 to 1.0. The array has an X,Y coordinate system which originates in the top left corner: thus, position (0,0) is in the top left corner, while position (512,512) is in the bottom right corner. This is how the 2D array looks like (just an excerpt): X,Y,Value 0,0,0.482 0,1,0.49 0,2,0.496 0,3,0.495 0,4,0.49 0,5,0.489 0,6,0.5 0,7,0.504 0,8,0.494 0,9,0.485 I would like to be able to: Find the regions of cells which value exceeds a given threshold, say 0.75; Note: If two elements touch horizontally, vertically or diagnoally, they belong to one region. Determine the distance between the center of mass of such regions and the top left corner, which has coordinates (0,0). Please output the distances as a list. A: <code> import numpy as np from scipy import ndimage np.random.seed(10) gen = np.random.RandomState(0) img = gen.poisson(2, size=(512, 512)) img = ndimage.gaussian_filter(img.astype(np.double), (30, 30)) img -= img.min() img /= img.max() threshold = 0.75 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

blobs = img > threshold labels, nlabels = ndimage.label(blobs) r, c = np.vstack(ndimage.center_of_mass(img, labels, np.arange(nlabels) + 1)).T # find their distances from the top-left corner d = np.sqrt(r * r + c * c) result = sorted(d)

import numpy as np import copy from scipy import ndimage def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) gen = np.random.RandomState(0) img = gen.poisson(2, size=(512, 512)) img = ndimage.gaussian_filter(img.astype(np.double), (30, 30)) img -= img.min() img /= img.max() return img def generate_ans(data): _a = data img = _a threshold = 0.75 blobs = img > threshold labels, nlabels = ndimage.label(blobs) r, c = np.vstack(ndimage.center_of_mass(img, labels, np.arange(nlabels) + 1)).T d = np.sqrt(r * r + c * c) result = sorted(d) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(sorted(result), ans) return 1 exec_context = r""" import numpy as np from scipy import ndimage img = test_input threshold = 0.75 [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: Is there a simple and efficient way to make a sparse scipy matrix (e.g. lil_matrix, or csr_matrix) symmetric? Currently I have a lil sparse matrix, and not both of sA[i,j] and sA[j,i] have element for any i,j. When populating a large sparse co-occurrence matrix it would be highly inefficient to fill in [row, col] and [col, row] at the same time. What I'd like to be doing is: for i in data: for j in data: if have_element(i, j): lil_sparse_matrix[i, j] = some_value # want to avoid this: # lil_sparse_matrix[j, i] = some_value # this is what I'm looking for: lil_sparse.make_symmetric() and it let sA[i,j] = sA[j,i] for any i, j. This is similar to <a href="https://stackoverflow.com/questions/2572916/numpy-smart-symmetric-matrix">stackoverflow's numpy-smart-symmetric-matrix question, but is particularly for scipy sparse matrices. A: <code> import numpy as np from scipy.sparse import lil_matrix from scipy import sparse M= sparse.random(10, 10, density=0.1, format='lil') </code> M = ... # put solution in this variable BEGIN SOLUTION <code>

rows, cols = M.nonzero() M[cols, rows] = M[rows, cols]

import copy import tokenize, io from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: sA = sparse.random(10, 10, density=0.1, format="lil", random_state=42) return sA def generate_ans(data): _a = data M = _a rows, cols = M.nonzero() M[cols, rows] = M[rows, cols] return M test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert len(sparse.find(result != ans)[0]) == 0 return 1 exec_context = r""" import numpy as np from scipy.sparse import lil_matrix from scipy import sparse M = test_input [insert] result = M """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert "while" not in tokens and "for" not in tokens

Problem: Is there a simple and efficient way to make a sparse scipy matrix (e.g. lil_matrix, or csr_matrix) symmetric? Currently I have a lil sparse matrix, and not both of sA[i,j] and sA[j,i] have element for any i,j. When populating a large sparse co-occurrence matrix it would be highly inefficient to fill in [row, col] and [col, row] at the same time. What I'd like to be doing is: for i in data: for j in data: if have_element(i, j): lil_sparse_matrix[i, j] = some_value # want to avoid this: # lil_sparse_matrix[j, i] = some_value # this is what I'm looking for: lil_sparse.make_symmetric() and it let sA[i,j] = sA[j,i] for any i, j. This is similar to <a href="https://stackoverflow.com/questions/2572916/numpy-smart-symmetric-matrix">stackoverflow's numpy-smart-symmetric-matrix question, but is particularly for scipy sparse matrices. A: <code> import numpy as np from scipy.sparse import lil_matrix example_sA = sparse.random(10, 10, density=0.1, format='lil') def f(sA = example_sA): # return the solution in this function # sA = f(sA) ### BEGIN SOLUTION

rows, cols = sA.nonzero() sA[cols, rows] = sA[rows, cols] return sA

import copy import tokenize, io from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: sA = sparse.random(10, 10, density=0.1, format="lil", random_state=42) return sA def generate_ans(data): _a = data sA = _a rows, cols = sA.nonzero() sA[cols, rows] = sA[rows, cols] return sA test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert len(sparse.find(result != ans)[0]) == 0 return 1 exec_context = r""" import numpy as np from scipy.sparse import lil_matrix def f(sA): [insert] sA = test_input result = f(sA) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert "while" not in tokens and "for" not in tokens

Problem: I'm trying to reduce noise in a binary python array by removing all completely isolated single cells, i.e. setting "1" value cells to 0 if they are completely surrounded by other "0"s like this: 0 0 0 0 1 0 0 0 0 I have been able to get a working solution by removing blobs with sizes equal to 1 using a loop, but this seems like a very inefficient solution for large arrays. In this case, eroding and dilating my array won't work as it will also remove features with a width of 1. I feel the solution lies somewhere within the scipy.ndimage package, but so far I haven't been able to crack it. Any help would be greatly appreciated! A: <code> import numpy as np import scipy.ndimage square = np.zeros((32, 32)) square[10:-10, 10:-10] = 1 np.random.seed(12) x, y = (32*np.random.random((2, 20))).astype(int) square[x, y] = 1 </code> square = ... # put solution in this variable BEGIN SOLUTION <code>

def filter_isolated_cells(array, struct): filtered_array = np.copy(array) id_regions, num_ids = scipy.ndimage.label(filtered_array, structure=struct) id_sizes = np.array(scipy.ndimage.sum(array, id_regions, range(num_ids + 1))) area_mask = (id_sizes == 1) filtered_array[area_mask[id_regions]] = 0 return filtered_array square = filter_isolated_cells(square, struct=np.ones((3,3)))

import numpy as np import copy import tokenize, io import scipy.ndimage def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: square = np.zeros((32, 32)) square[10:-10, 10:-10] = 1 np.random.seed(12) x, y = (32 * np.random.random((2, 20))).astype(int) square[x, y] = 1 return square def generate_ans(data): _a = data square = _a def filter_isolated_cells(array, struct): filtered_array = np.copy(array) id_regions, num_ids = scipy.ndimage.label(filtered_array, structure=struct) id_sizes = np.array( scipy.ndimage.sum(array, id_regions, range(num_ids + 1)) ) area_mask = id_sizes == 1 filtered_array[area_mask[id_regions]] = 0 return filtered_array square = filter_isolated_cells(square, struct=np.ones((3, 3))) return square test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np import scipy.ndimage square = test_input [insert] result = square """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert "while" not in tokens and "for" not in tokens

Problem: I'm trying to reduce noise in a python image array by removing all completely isolated single cells, i.e. setting nonzero value cells to 0 if they are completely surrounded by other "0"s like this: 0 0 0 0 8 0 0 0 0 I have been able to get a working solution by removing blobs with sizes equal to 1 using a loop, but this seems like a very inefficient solution for large arrays. In this case, eroding and dilating my array won't work as it will also remove features with a width of 1. I feel the solution lies somewhere within the scipy.ndimage package, but so far I haven't been able to crack it. Any help would be greatly appreciated! A: <code> import numpy as np import scipy.ndimage square = np.zeros((32, 32)) square[10:-10, 10:-10] = np.random.randint(1, 255, size = (12, 12)) np.random.seed(12) x, y = (32*np.random.random((2, 20))).astype(int) square[x, y] = np.random.randint(1, 255, size = (20,)) </code> square = ... # put solution in this variable BEGIN SOLUTION <code>

def filter_isolated_cells(array, struct): filtered_array = np.copy(array) id_regions, num_ids = scipy.ndimage.label(filtered_array, structure=struct) id_sizes = np.array(scipy.ndimage.sum(array, id_regions, range(num_ids + 1))) area_mask = (id_sizes == 1) filtered_array[area_mask[id_regions]] = 0 return filtered_array arr = np.sign(square) filtered_array = filter_isolated_cells(arr, struct=np.ones((3,3))) square = np.where(filtered_array==1, square, 0)

import numpy as np import copy import tokenize, io import scipy.ndimage def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(42) square = np.zeros((32, 32)) square[10:-10, 10:-10] = np.random.randint(1, 255, size=(12, 12)) np.random.seed(12) x, y = (32 * np.random.random((2, 20))).astype(int) square[x, y] = np.random.randint(1, 255, size=(20,)) return square def generate_ans(data): _a = data square = _a def filter_isolated_cells(array, struct): filtered_array = np.copy(array) id_regions, num_ids = scipy.ndimage.label(filtered_array, structure=struct) id_sizes = np.array( scipy.ndimage.sum(array, id_regions, range(num_ids + 1)) ) area_mask = id_sizes == 1 filtered_array[area_mask[id_regions]] = 0 return filtered_array arr = np.sign(square) filtered_array = filter_isolated_cells(arr, struct=np.ones((3, 3))) square = np.where(filtered_array == 1, square, 0) return square test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np import scipy.ndimage square = test_input [insert] result = square """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert "while" not in tokens and "for" not in tokens

Problem: I have a sparse 988x1 vector (stored in col, a column in a csr_matrix) created through scipy.sparse. Is there a way to gets its mean and standard deviation without having to convert the sparse matrix to a dense one? numpy.mean seems to only work for dense vectors. A: <code> import numpy as np from scipy.sparse import csr_matrix np.random.seed(10) arr = np.random.randint(4,size=(988,988)) sA = csr_matrix(arr) col = sA.getcol(0) </code> mean, standard_deviation = ... # put solution in these variables BEGIN SOLUTION <code>

mean = col.mean() N = col.shape[0] sqr = col.copy() # take a copy of the col sqr.data **= 2 # square the data, i.e. just the non-zero data standard_deviation = np.sqrt(sqr.sum() / N - col.mean() ** 2)

import numpy as np import copy import tokenize, io from scipy.sparse import csr_matrix def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) elif test_case_id == 2: np.random.seed(42) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) elif test_case_id == 3: np.random.seed(80) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) elif test_case_id == 4: np.random.seed(100) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) return col def generate_ans(data): _a = data col = _a mean = col.mean() N = col.shape[0] sqr = col.copy() # take a copy of the col sqr.data **= 2 # square the data, i.e. just the non-zero data standard_deviation = np.sqrt(sqr.sum() / N - col.mean() ** 2) return [mean, standard_deviation] test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np from scipy.sparse import csr_matrix col = test_input [insert] result = [mean, standard_deviation] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(4): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert ( "toarray" not in tokens and "array" not in tokens and "todense" not in tokens and "A" not in tokens )

Problem: I have a sparse 988x1 vector (stored in col, a column in a csr_matrix) created through scipy.sparse. Is there a way to gets its max and min value without having to convert the sparse matrix to a dense one? numpy.max seems to only work for dense vectors. A: <code> import numpy as np from scipy.sparse import csr_matrix np.random.seed(10) arr = np.random.randint(4,size=(988,988)) sA = csr_matrix(arr) col = sA.getcol(0) </code> Max, Min = ... # put solution in these variables BEGIN SOLUTION <code>

Max, Min = col.max(), col.min()

import numpy as np import copy import tokenize, io from scipy.sparse import csr_matrix def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) elif test_case_id == 2: np.random.seed(42) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) elif test_case_id == 3: np.random.seed(80) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) elif test_case_id == 4: np.random.seed(100) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) return col def generate_ans(data): _a = data col = _a Max, Min = col.max(), col.min() return [Max, Min] test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np from scipy.sparse import csr_matrix col = test_input [insert] result = [Max, Min] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(4): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert ( "toarray" not in tokens and "array" not in tokens and "todense" not in tokens and "A" not in tokens )

Problem: I have a sparse 988x1 vector (stored in col, a column in a csr_matrix) created through scipy.sparse. Is there a way to gets its median and mode value without having to convert the sparse matrix to a dense one? numpy.median seems to only work for dense vectors. A: <code> import numpy as np from scipy.sparse import csr_matrix np.random.seed(10) arr = np.random.randint(4,size=(988,988)) sA = csr_matrix(arr) col = sA.getcol(0) </code> Median, Mode = ... # put solution in these variables BEGIN SOLUTION <code>

n = col.shape[0] val = col.data for i in range(n-len(val)): val = np.append(val,0) Median, Mode = np.median(val), np.argmax(np.bincount(val))

import numpy as np import copy import tokenize, io from scipy.sparse import csr_matrix def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) elif test_case_id == 2: np.random.seed(42) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) elif test_case_id == 3: np.random.seed(80) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) elif test_case_id == 4: np.random.seed(100) arr = np.random.randint(4, size=(988, 988)) A = csr_matrix(arr) col = A.getcol(0) return col def generate_ans(data): _a = data col = _a n = col.shape[0] val = col.data for i in range(n - len(val)): val = np.append(val, 0) Median, Mode = np.median(val), np.argmax(np.bincount(val)) return [Median, Mode] test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np from scipy.sparse import csr_matrix col = test_input [insert] result = [Median, Mode] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(4): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert ( "toarray" not in tokens and "array" not in tokens and "todense" not in tokens and "A" not in tokens )

Problem: I'd like to achieve a fourier series development for a x-y-dataset using numpy and scipy. At first I want to fit my data with the first 8 cosines and plot additionally only the first harmonic. So I wrote the following two function defintions: # fourier series defintions tau = 0.045 def fourier8(x, a1, a2, a3, a4, a5, a6, a7, a8): return a1 * np.cos(1 * np.pi / tau * x) + \ a2 * np.cos(2 * np.pi / tau * x) + \ a3 * np.cos(3 * np.pi / tau * x) + \ a4 * np.cos(4 * np.pi / tau * x) + \ a5 * np.cos(5 * np.pi / tau * x) + \ a6 * np.cos(6 * np.pi / tau * x) + \ a7 * np.cos(7 * np.pi / tau * x) + \ a8 * np.cos(8 * np.pi / tau * x) def fourier1(x, a1): return a1 * np.cos(1 * np.pi / tau * x) Then I use them to fit my data: # import and filename filename = 'data.txt' import numpy as np from scipy.optimize import curve_fit z, Ua = np.loadtxt(filename,delimiter=',', unpack=True) tau = 0.045 popt, pcov = curve_fit(fourier8, z, Ua) which works as desired But know I got stuck making it generic for arbitary orders of harmonics, e.g. I want to fit my data with the first fifteen harmonics. How could I achieve that without defining fourier1, fourier2, fourier3 ... , fourier15? By the way, initial guess of a1,a2,… should be set to default value. A: <code> from scipy.optimize import curve_fit import numpy as np s = '''1.000000000000000021e-03,2.794682735905079767e+02 4.000000000000000083e-03,2.757183469104809888e+02 1.400000000000000029e-02,2.791403179603880176e+02 2.099999999999999784e-02,1.781413355804160119e+02 3.300000000000000155e-02,-2.798375517344049968e+02 4.199999999999999567e-02,-2.770513900380149721e+02 5.100000000000000366e-02,-2.713769422793179729e+02 6.900000000000000577e-02,1.280740698304900036e+02 7.799999999999999989e-02,2.800801708984579932e+02 8.999999999999999667e-02,2.790400329037249776e+02'''.replace('\n', ';') arr = np.matrix(s) z = np.array(arr[:, 0]).squeeze() Ua = np.array(arr[:, 1]).squeeze() tau = 0.045 degree = 15 </code> popt, pcov = ... # put solution in these variables BEGIN SOLUTION <code>

def fourier(x, *a): ret = a[0] * np.cos(np.pi / tau * x) for deg in range(1, len(a)): ret += a[deg] * np.cos((deg+1) * np.pi / tau * x) return ret popt, pcov = curve_fit(fourier, z, Ua, [1.0] * degree)

import numpy as np import copy from scipy.optimize import curve_fit def generate_test_case(test_case_id): def define_test_input(test_case_id): s = """1.000000000000000021e-03,2.794682735905079767e+02 2.000000000000000042e-03,2.792294526290349950e+02 2.999999999999999629e-03,2.779794770690260179e+02 4.000000000000000083e-03,2.757183469104809888e+02 5.000000000000000104e-03,2.734572167519349932e+02 5.999999999999999258e-03,2.711960865933900209e+02 7.000000000000000146e-03,2.689349564348440254e+02 8.000000000000000167e-03,2.714324329982829909e+02 8.999999999999999320e-03,2.739299095617229796e+02 1.000000000000000021e-02,2.764273861251620019e+02 1.100000000000000110e-02,2.789248626886010243e+02 1.199999999999999852e-02,2.799669443683339978e+02 1.299999999999999940e-02,2.795536311643609793e+02 1.400000000000000029e-02,2.791403179603880176e+02 1.499999999999999944e-02,2.787270047564149991e+02 1.600000000000000033e-02,2.783136915524419805e+02 1.699999999999999775e-02,2.673604939531239779e+02 1.799999999999999864e-02,2.564072963538059753e+02 1.899999999999999953e-02,2.454540987544889958e+02 2.000000000000000042e-02,2.345009011551709932e+02 2.099999999999999784e-02,1.781413355804160119e+02 2.200000000000000219e-02,7.637540203022649621e+01 2.299999999999999961e-02,-2.539053151996269975e+01 2.399999999999999703e-02,-1.271564650701519952e+02 2.500000000000000139e-02,-2.289223986203409993e+02 2.599999999999999881e-02,-2.399383538664330047e+02 2.700000000000000316e-02,-2.509543091125239869e+02 2.800000000000000058e-02,-2.619702643586149975e+02 2.899999999999999800e-02,-2.729862196047059797e+02 2.999999999999999889e-02,-2.786861050144170235e+02 3.099999999999999978e-02,-2.790699205877460258e+02 3.200000000000000067e-02,-2.794537361610759945e+02 3.300000000000000155e-02,-2.798375517344049968e+02 3.399999999999999550e-02,-2.802213673077350222e+02 3.500000000000000333e-02,-2.776516459805940258e+02 3.599999999999999728e-02,-2.750819246534539957e+02 3.700000000000000511e-02,-2.725122033263129993e+02 3.799999999999999906e-02,-2.699424819991720028e+02 3.899999999999999994e-02,-2.698567311502329744e+02 4.000000000000000083e-02,-2.722549507794930150e+02 4.100000000000000172e-02,-2.746531704087540220e+02 4.199999999999999567e-02,-2.770513900380149721e+02 4.299999999999999656e-02,-2.794496096672759791e+02 4.400000000000000439e-02,-2.800761105821779893e+02 4.499999999999999833e-02,-2.800761105821779893e+02 4.599999999999999922e-02,-2.800761105821779893e+02 4.700000000000000011e-02,-2.800761105821779893e+02 4.799999999999999406e-02,-2.788333722531979788e+02 4.900000000000000189e-02,-2.763478955952380147e+02 5.000000000000000278e-02,-2.738624189372779938e+02 5.100000000000000366e-02,-2.713769422793179729e+02 5.199999999999999761e-02,-2.688914656213580088e+02 5.299999999999999850e-02,-2.715383673199499981e+02 5.400000000000000633e-02,-2.741852690185419874e+02 5.499999999999999334e-02,-2.768321707171339767e+02 5.600000000000000117e-02,-2.794790724157260229e+02 5.700000000000000205e-02,-2.804776351435970128e+02 5.799999999999999600e-02,-2.798278589007459800e+02 5.899999999999999689e-02,-2.791780826578950041e+02 5.999999999999999778e-02,-2.785283064150449945e+02 6.100000000000000561e-02,-2.778785301721940186e+02 6.199999999999999956e-02,-2.670252067497989970e+02 6.300000000000000044e-02,-2.561718833274049985e+02 6.400000000000000133e-02,-2.453185599050100052e+02 6.500000000000000222e-02,-2.344652364826150119e+02 6.600000000000000311e-02,-1.780224826854309867e+02 6.700000000000000400e-02,-7.599029851345700592e+01 6.799999999999999101e-02,2.604188565851649884e+01 6.900000000000000577e-02,1.280740698304900036e+02 7.000000000000000666e-02,2.301062540024639986e+02 7.100000000000000755e-02,2.404921248105050040e+02 7.199999999999999456e-02,2.508779956185460094e+02 7.299999999999999545e-02,2.612638664265870148e+02 7.400000000000001021e-02,2.716497372346279917e+02 7.499999999999999722e-02,2.773051723900500178e+02 7.599999999999999811e-02,2.782301718928520131e+02 7.699999999999999900e-02,2.791551713956549747e+02 7.799999999999999989e-02,2.800801708984579932e+02 7.900000000000001465e-02,2.810051704012610116e+02 8.000000000000000167e-02,2.785107135689390248e+02 8.099999999999998868e-02,2.760162567366169810e+02 8.200000000000000344e-02,2.735217999042949941e+02 8.300000000000000433e-02,2.710273430719730072e+02 8.399999999999999134e-02,2.706544464035359852e+02 8.500000000000000611e-02,2.724031098989830184e+02 8.599999999999999312e-02,2.741517733944299948e+02 8.699999999999999400e-02,2.759004368898779944e+02 8.800000000000000877e-02,2.776491003853250277e+02 8.899999999999999578e-02,2.783445666445250026e+02 8.999999999999999667e-02,2.790400329037249776e+02""".replace( "\n", ";" ) arr = np.matrix(s) z = np.array(arr[:, 0]).squeeze() Ua = np.array(arr[:, 1]).squeeze() tau = 0.045 if test_case_id == 1: degree = 15 elif test_case_id == 2: np.random.seed(42) degree = np.random.randint(15, 25) return z, Ua, tau, degree def generate_ans(data): _a = data z, Ua, tau, degree = _a def fourier(x, *a): ret = a[0] * np.cos(np.pi / tau * x) for deg in range(1, len(a)): ret += a[deg] * np.cos((deg + 1) * np.pi / tau * x) return ret popt, pcov = curve_fit(fourier, z, Ua, [1.0] * degree) return [popt, pcov] test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result[0], ans[0], atol=1e-3) np.testing.assert_allclose(result[1], ans[1], atol=1e-2) return 1 exec_context = r""" from scipy.optimize import curve_fit import numpy as np z, Ua, tau, degree = test_input [insert] result = [popt, pcov] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a raster with a set of unique ID patches/regions which I've converted into a two-dimensional Python numpy array. I would like to calculate pairwise Euclidean distances between all regions to obtain the minimum distance separating the nearest edges of each raster patch. As the array was originally a raster, a solution needs to account for diagonal distances across cells (I can always convert any distances measured in cells back to metres by multiplying by the raster resolution). I've experimented with the cdist function from scipy.spatial.distance as suggested in this answer to a related question, but so far I've been unable to solve my problem using the available documentation. As an end result I would ideally have a N*N array in the form of "from ID, to ID, distance", including distances between all possible combinations of regions. Here's a sample dataset resembling my input data: import numpy as np import matplotlib.pyplot as plt # Sample study area array example_array = np.array([[0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 2, 0, 6, 0, 3, 3, 3], [0, 0, 0, 0, 2, 2, 0, 0, 0, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 5, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]]) # Plot array plt.imshow(example_array, cmap="spectral", interpolation='nearest') A: <code> import numpy as np import scipy.spatial.distance example_array = np.array([[0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 2, 0, 6, 0, 3, 3, 3], [0, 0, 0, 0, 2, 2, 0, 0, 0, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 5, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]]) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

import itertools n = example_array.max()+1 indexes = [] for k in range(1, n): tmp = np.nonzero(example_array == k) tmp = np.asarray(tmp).T indexes.append(tmp) result = np.zeros((n-1, n-1)) for i, j in itertools.combinations(range(n-1), 2): d2 = scipy.spatial.distance.cdist(indexes[i], indexes[j], metric='sqeuclidean') result[i, j] = result[j, i] = d2.min()**0.5

import numpy as np import itertools import copy import scipy.spatial.distance def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: example_array = np.array( [ [0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 2, 0, 6, 0, 3, 3, 3], [0, 0, 0, 0, 2, 2, 0, 0, 0, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 5, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], ] ) return example_array def generate_ans(data): _a = data example_array = _a n = example_array.max() + 1 indexes = [] for k in range(1, n): tmp = np.nonzero(example_array == k) tmp = np.asarray(tmp).T indexes.append(tmp) result = np.zeros((n - 1, n - 1)) for i, j in itertools.combinations(range(n - 1), 2): d2 = scipy.spatial.distance.cdist( indexes[i], indexes[j], metric="sqeuclidean" ) result[i, j] = result[j, i] = d2.min() ** 0.5 return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.spatial.distance example_array = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a raster with a set of unique ID patches/regions which I've converted into a two-dimensional Python numpy array. I would like to calculate pairwise Manhattan distances between all regions to obtain the minimum distance separating the nearest edges of each raster patch. I've experimented with the cdist function from scipy.spatial.distance as suggested in this answer to a related question, but so far I've been unable to solve my problem using the available documentation. As an end result I would ideally have a N*N array in the form of "from ID, to ID, distance", including distances between all possible combinations of regions. Here's a sample dataset resembling my input data: import numpy as np import matplotlib.pyplot as plt # Sample study area array example_array = np.array([[0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 2, 0, 6, 0, 3, 3, 3], [0, 0, 0, 0, 2, 2, 0, 0, 0, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 5, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]]) # Plot array plt.imshow(example_array, cmap="spectral", interpolation='nearest') A: <code> import numpy as np import scipy.spatial.distance example_array = np.array([[0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 2, 0, 6, 0, 3, 3, 3], [0, 0, 0, 0, 2, 2, 0, 0, 0, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 5, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]]) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

import itertools n = example_array.max()+1 indexes = [] for k in range(1, n): tmp = np.nonzero(example_array == k) tmp = np.asarray(tmp).T indexes.append(tmp) result = np.zeros((n-1, n-1), dtype=float) for i, j in itertools.combinations(range(n-1), 2): d2 = scipy.spatial.distance.cdist(indexes[i], indexes[j], metric='minkowski', p=1) result[i, j] = result[j, i] = d2.min()

import numpy as np import itertools import copy import scipy.spatial.distance def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: example_array = np.array( [ [0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 2, 0, 6, 0, 3, 3, 3], [0, 0, 0, 0, 2, 2, 0, 0, 0, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 5, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], ] ) return example_array def generate_ans(data): _a = data example_array = _a n = example_array.max() + 1 indexes = [] for k in range(1, n): tmp = np.nonzero(example_array == k) tmp = np.asarray(tmp).T indexes.append(tmp) result = np.zeros((n - 1, n - 1), dtype=float) for i, j in itertools.combinations(range(n - 1), 2): d2 = scipy.spatial.distance.cdist( indexes[i], indexes[j], metric="minkowski", p=1 ) result[i, j] = result[j, i] = d2.min() return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.spatial.distance example_array = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a raster with a set of unique ID patches/regions which I've converted into a two-dimensional Python numpy array. I would like to calculate pairwise Euclidean distances between all regions to obtain the minimum distance separating the nearest edges of each raster patch. As the array was originally a raster, a solution needs to account for diagonal distances across cells (I can always convert any distances measured in cells back to metres by multiplying by the raster resolution). I've experimented with the cdist function from scipy.spatial.distance as suggested in this answer to a related question, but so far I've been unable to solve my problem using the available documentation. As an end result I would ideally have a N*N array in the form of "from ID, to ID, distance", including distances between all possible combinations of regions. Here's a sample dataset resembling my input data: import numpy as np import matplotlib.pyplot as plt # Sample study area array example_array = np.array([[0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 2, 0, 6, 0, 3, 3, 3], [0, 0, 0, 0, 2, 2, 0, 0, 0, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 5, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]]) # Plot array plt.imshow(example_array, cmap="spectral", interpolation='nearest') A: <code> import numpy as np import scipy.spatial.distance example_arr = np.array([[0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 2, 0, 6, 0, 3, 3, 3], [0, 0, 0, 0, 2, 2, 0, 0, 0, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 5, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4]]) def f(example_array = example_arr): # return the solution in this function # result = f(example_array) ### BEGIN SOLUTION

import itertools n = example_array.max()+1 indexes = [] for k in range(1, n): tmp = np.nonzero(example_array == k) tmp = np.asarray(tmp).T indexes.append(tmp) result = np.zeros((n-1, n-1)) for i, j in itertools.combinations(range(n-1), 2): d2 = scipy.spatial.distance.cdist(indexes[i], indexes[j], metric='sqeuclidean') result[i, j] = result[j, i] = d2.min()**0.5 return result

import numpy as np import itertools import copy import scipy.spatial.distance def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: example_array = np.array( [ [0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 2, 0, 6, 0, 3, 3, 3], [0, 0, 0, 0, 2, 2, 0, 0, 0, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 3], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 1, 1, 0, 0, 0, 3, 3, 3, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0, 5, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4], ] ) return example_array def generate_ans(data): _a = data example_array = _a n = example_array.max() + 1 indexes = [] for k in range(1, n): tmp = np.nonzero(example_array == k) tmp = np.asarray(tmp).T indexes.append(tmp) result = np.zeros((n - 1, n - 1)) for i, j in itertools.combinations(range(n - 1), 2): d2 = scipy.spatial.distance.cdist( indexes[i], indexes[j], metric="sqeuclidean" ) result[i, j] = result[j, i] = d2.min() ** 0.5 return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.spatial.distance example_array = test_input def f(example_array): [insert] result = f(example_array) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I am able to interpolate the data points (dotted lines), and am looking to extrapolate them in both direction. How can I extrapolate these curves in Python with NumPy/SciPy? The code I used for the interpolation is given below, import numpy as np import matplotlib.pyplot as plt from scipy import interpolate x = np.array([[0.12, 0.11, 0.1, 0.09, 0.08], [0.13, 0.12, 0.11, 0.1, 0.09], [0.15, 0.14, 0.12, 0.11, 0.1], [0.17, 0.15, 0.14, 0.12, 0.11], [0.19, 0.17, 0.16, 0.14, 0.12], [0.22, 0.19, 0.17, 0.15, 0.13], [0.24, 0.22, 0.19, 0.16, 0.14], [0.27, 0.24, 0.21, 0.18, 0.15], [0.29, 0.26, 0.22, 0.19, 0.16]]) y = np.array([[71.64, 78.52, 84.91, 89.35, 97.58], [66.28, 73.67, 79.87, 85.36, 93.24], [61.48, 69.31, 75.36, 81.87, 89.35], [57.61, 65.75, 71.7, 79.1, 86.13], [55.12, 63.34, 69.32, 77.29, 83.88], [54.58, 62.54, 68.7, 76.72, 82.92], [56.58, 63.87, 70.3, 77.69, 83.53], [61.67, 67.79, 74.41, 80.43, 85.86], [70.08, 74.62, 80.93, 85.06, 89.84]]) plt.figure(figsize = (5.15,5.15)) plt.subplot(111) for i in range(5): x_val = np.linspace(x[0, i], x[-1, i], 100) x_int = np.interp(x_val, x[:, i], y[:, i]) tck = interpolate.splrep(x[:, i], y[:, i], k = 2, s = 4) y_int = interpolate.splev(x_val, tck, der = 0) plt.plot(x[:, i], y[:, i], linestyle = '', marker = 'o') plt.plot(x_val, y_int, linestyle = ':', linewidth = 0.25, color = 'black') plt.xlabel('X') plt.ylabel('Y') plt.show() That seems only work for interpolation. I want to use B-spline (with the same parameters setting as in the code) in scipy to do extrapolation. The result should be (5, 100) array containing f(x_val) for each group of x, y(just as shown in the code). A: <code> from scipy import interpolate import numpy as np x = np.array([[0.12, 0.11, 0.1, 0.09, 0.08], [0.13, 0.12, 0.11, 0.1, 0.09], [0.15, 0.14, 0.12, 0.11, 0.1], [0.17, 0.15, 0.14, 0.12, 0.11], [0.19, 0.17, 0.16, 0.14, 0.12], [0.22, 0.19, 0.17, 0.15, 0.13], [0.24, 0.22, 0.19, 0.16, 0.14], [0.27, 0.24, 0.21, 0.18, 0.15], [0.29, 0.26, 0.22, 0.19, 0.16]]) y = np.array([[71.64, 78.52, 84.91, 89.35, 97.58], [66.28, 73.67, 79.87, 85.36, 93.24], [61.48, 69.31, 75.36, 81.87, 89.35], [57.61, 65.75, 71.7, 79.1, 86.13], [55.12, 63.34, 69.32, 77.29, 83.88], [54.58, 62.54, 68.7, 76.72, 82.92], [56.58, 63.87, 70.3, 77.69, 83.53], [61.67, 67.79, 74.41, 80.43, 85.86], [70.08, 74.62, 80.93, 85.06, 89.84]]) x_val = np.linspace(-1, 1, 100) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = np.zeros((5, 100)) for i in range(5): extrapolator = interpolate.UnivariateSpline(x[:, i], y[:, i], k = 2, s = 4) y_int = extrapolator(x_val) result[i, :] = y_int

import numpy as np import copy from scipy import interpolate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: x = np.array( [ [0.12, 0.11, 0.1, 0.09, 0.08], [0.13, 0.12, 0.11, 0.1, 0.09], [0.15, 0.14, 0.12, 0.11, 0.1], [0.17, 0.15, 0.14, 0.12, 0.11], [0.19, 0.17, 0.16, 0.14, 0.12], [0.22, 0.19, 0.17, 0.15, 0.13], [0.24, 0.22, 0.19, 0.16, 0.14], [0.27, 0.24, 0.21, 0.18, 0.15], [0.29, 0.26, 0.22, 0.19, 0.16], ] ) y = np.array( [ [71.64, 78.52, 84.91, 89.35, 97.58], [66.28, 73.67, 79.87, 85.36, 93.24], [61.48, 69.31, 75.36, 81.87, 89.35], [57.61, 65.75, 71.7, 79.1, 86.13], [55.12, 63.34, 69.32, 77.29, 83.88], [54.58, 62.54, 68.7, 76.72, 82.92], [56.58, 63.87, 70.3, 77.69, 83.53], [61.67, 67.79, 74.41, 80.43, 85.86], [70.08, 74.62, 80.93, 85.06, 89.84], ] ) x_val = np.linspace(-1, 1, 100) return x, y, x_val def generate_ans(data): _a = data x, y, x_val = _a result = np.zeros((5, 100)) for i in range(5): extrapolator = interpolate.UnivariateSpline(x[:, i], y[:, i], k=2, s=4) y_int = extrapolator(x_val) result[i, :] = y_int return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" from scipy import interpolate import numpy as np x, y, x_val = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: How do we pass four datasets in scipy.stats.anderson_ksamp? The anderson function asks only for one parameter and that should be 1-d array. So I am wondering how to pass four different arrays to be compared in it? Thanks A: <code> import numpy as np import scipy.stats as ss x1=[38.7, 41.5, 43.8, 44.5, 45.5, 46.0, 47.7, 58.0] x2=[39.2, 39.3, 39.7, 41.4, 41.8, 42.9, 43.3, 45.8] x3=[34.0, 35.0, 39.0, 40.0, 43.0, 43.0, 44.0, 45.0] x4=[34.0, 34.8, 34.8, 35.4, 37.2, 37.8, 41.2, 42.8] </code> statistic, critical_values, significance_level = ... # put solution in these variables BEGIN SOLUTION <code>

statistic, critical_values, significance_level = ss.anderson_ksamp([x1,x2,x3,x4])

import numpy as np import copy import scipy.stats as ss def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: x1 = [38.7, 41.5, 43.8, 44.5, 45.5, 46.0, 47.7, 58.0] x2 = [39.2, 39.3, 39.7, 41.4, 41.8, 42.9, 43.3, 45.8] x3 = [34.0, 35.0, 39.0, 40.0, 43.0, 43.0, 44.0, 45.0] x4 = [34.0, 34.8, 34.8, 35.4, 37.2, 37.8, 41.2, 42.8] elif test_case_id == 2: np.random.seed(42) x1, x2, x3, x4 = np.random.randn(4, 20) return x1, x2, x3, x4 def generate_ans(data): _a = data x1, x2, x3, x4 = _a statistic, critical_values, significance_level = ss.anderson_ksamp( [x1, x2, x3, x4] ) return [statistic, critical_values, significance_level] test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert abs(result[0] - ans[0]) <= 1e-5 assert np.allclose(result[1], ans[1]) assert abs(result[2] - ans[2]) <= 1e-5 return 1 exec_context = r""" import numpy as np import scipy.stats as ss x1, x2, x3, x4 = test_input [insert] result = [statistic, critical_values, significance_level] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: How do we pass two datasets in scipy.stats.anderson_ksamp? The anderson function asks only for one parameter and that should be 1-d array. So I am wondering how to pass two different arrays to be compared in it? Further, I want to interpret the result, that is, telling whether the two different arrays are drawn from the same population at the 5% significance level, result should be `True` or `False` . A: <code> import numpy as np import scipy.stats as ss x1=[38.7, 41.5, 43.8, 44.5, 45.5, 46.0, 47.7, 58.0] x2=[39.2, 39.3, 39.7, 41.4, 41.8, 42.9, 43.3, 45.8] </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

s, c_v, s_l = ss.anderson_ksamp([x1,x2]) result = c_v[2] >= s

import numpy as np import copy import scipy.stats as ss def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: x1 = [38.7, 41.5, 43.8, 44.5, 45.5, 46.0, 47.7, 58.0] x2 = [39.2, 39.3, 39.7, 41.4, 41.8, 42.9, 43.3, 45.8] elif test_case_id == 2: np.random.seed(42) x1, x2 = np.random.randn(2, 20) elif test_case_id == 3: np.random.seed(20) x1 = np.random.randn(10) x2 = np.random.normal(4, 5, size=(10,)) return x1, x2 def generate_ans(data): _a = data x1, x2 = _a s, c_v, s_l = ss.anderson_ksamp([x1, x2]) result = c_v[2] >= s return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert result == ans return 1 exec_context = r""" import numpy as np import scipy.stats as ss x1, x2 = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(3): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm trying to use rollapply with a formula that requires 2 arguments. To my knowledge the only way (unless you create the formula from scratch) to calculate kendall tau correlation, with standard tie correction included is: >>> import scipy >>> x = [5.05, 6.75, 3.21, 2.66] >>> y = [1.65, 26.5, -5.93, 7.96] >>> z = [1.65, 2.64, 2.64, 6.95] >>> print scipy.stats.stats.kendalltau(x, y)[0] 0.333333333333 I'm also aware of the problem with rollapply and taking two arguments, as documented here: • Related Question 1 • Github Issue • Related Question 2 Still, I'm struggling to find a way to do the kendalltau calculation on a dataframe with multiple columns on a rolling basis. My dataframe is something like this A = pd.DataFrame([[1, 5, 1], [2, 4, 1], [3, 3, 1], [4, 2, 1], [5, 1, 1]], columns=['A', 'B', 'C'], index = [1, 2, 3, 4, 5]) Trying to create a function that does this In [1]:function(A, 3) # A is df, 3 is the rolling window Out[2]: A B C AB AC BC 1 1 5 2 NaN NaN NaN 2 2 4 4 NaN NaN NaN 3 3 3 1 -1.00 -0.333 0.333 4 4 2 2 -1.00 -0.333 0.333 5 5 1 4 -1.00 1.00 -1.00 In a very preliminary approach I entertained the idea of defining the function like this: def tau1(x): y = np.array(A['A']) # keep one column fix and run it in the other two tau, p_value = sp.stats.kendalltau(x, y) return tau A['AB'] = pd.rolling_apply(A['B'], 3, lambda x: tau1(x)) Off course It didn't work. I got: ValueError: all keys need to be the same shape I understand is not a trivial problem. I appreciate any input. A: <code> import pandas as pd import numpy as np import scipy.stats as stats df = pd.DataFrame([[1, 5, 2], [2, 4, 4], [3, 3, 1], [4, 2, 2], [5, 1, 4]], columns=['A', 'B', 'C'], index = [1, 2, 3, 4, 5]) </code> df = ... # put solution in this variable BEGIN SOLUTION <code>

import itertools as IT for col1, col2 in IT.combinations(df.columns, 2): def tau(idx): B = df[[col1, col2]].iloc[idx] return stats.kendalltau(B[col1], B[col2])[0] df[col1+col2] = pd.Series(np.arange(len(df)), index=df.index).rolling(3).apply(tau)

import numpy as np import pandas as pd import itertools as IT import copy import scipy.stats as stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: df = pd.DataFrame( [[1, 5, 2], [2, 4, 4], [3, 3, 1], [4, 2, 2], [5, 1, 4]], columns=["A", "B", "C"], index=[1, 2, 3, 4, 5], ) elif test_case_id == 2: df = pd.DataFrame( [[1, 3, 2], [2, 5, 4], [2, 3, 1], [1, 2, 2], [5, 8, 4]], columns=["A", "B", "C"], index=[1, 2, 3, 4, 5], ) return df def generate_ans(data): _a = data df = _a for col1, col2 in IT.combinations(df.columns, 2): def tau(idx): B = df[[col1, col2]].iloc[idx] return stats.kendalltau(B[col1], B[col2])[0] df[col1 + col2] = ( pd.Series(np.arange(len(df)), index=df.index).rolling(3).apply(tau) ) return df test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): pd.testing.assert_frame_equal(result, ans, atol=1e-3, check_dtype=False) return 1 exec_context = r""" import pandas as pd import numpy as np import scipy.stats as stats df = test_input [insert] result = df """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: What is the canonical way to check if a SciPy CSR matrix is empty (i.e. contains only zeroes)? I use nonzero(): def is_csr_matrix_only_zeroes(my_csr_matrix): return(len(my_csr_matrix.nonzero()[0]) == 0) from scipy.sparse import csr_matrix print(is_csr_matrix_only_zeroes(csr_matrix([[1,2,0],[0,0,3],[4,0,5]]))) print(is_csr_matrix_only_zeroes(csr_matrix([[0,0,0],[0,0,0],[0,0,0]]))) print(is_csr_matrix_only_zeroes(csr_matrix((2,3)))) print(is_csr_matrix_only_zeroes(csr_matrix([[0,0,0],[0,1,0],[0,0,0]]))) outputs False True True False but I wonder whether there exist more direct or efficient ways, i.e. just get True or False? A: <code> from scipy import sparse sa = sparse.random(10, 10, density = 0.01, format = 'csr') </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = (sa.count_nonzero()==0)

import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: sa = sparse.random(10, 10, density=0.01, format="csr", random_state=42) elif test_case_id == 2: sa = sparse.csr_matrix([]) return sa def generate_ans(data): _a = data sa = _a result = sa.count_nonzero() == 0 return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert result == ans return 1 exec_context = r""" from scipy import sparse sa = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: What is the canonical way to check if a SciPy lil matrix is empty (i.e. contains only zeroes)? I use nonzero(): def is_lil_matrix_only_zeroes(my_lil_matrix): return(len(my_lil_matrix.nonzero()[0]) == 0) from scipy.sparse import csr_matrix print(is_lil_matrix_only_zeroes(lil_matrix([[1,2,0],[0,0,3],[4,0,5]]))) print(is_lil_matrix_only_zeroes(lil_matrix([[0,0,0],[0,0,0],[0,0,0]]))) print(is_lil_matrix_only_zeroes(lil_matrix((2,3)))) print(is_lil_matrix_only_zeroes(lil_matrix([[0,0,0],[0,1,0],[0,0,0]]))) outputs False True True False but I wonder whether there exist more direct or efficient ways, i.e. just get True or False? A: <code> from scipy import sparse sa = sparse.random(10, 10, density = 0.01, format = 'lil') </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = (sa.count_nonzero()==0)

import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: sa = sparse.random(10, 10, density=0.01, format="lil", random_state=42) elif test_case_id == 2: sa = sparse.lil_matrix([]) return sa def generate_ans(data): _a = data sa = _a result = sa.count_nonzero() == 0 return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert result == ans return 1 exec_context = r""" from scipy import sparse sa = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I am looking for a way to convert a nXaXb numpy array into a block diagonal matrix. I have already came across scipy.linalg.block_diag, the down side of which (for my case) is it requires each blocks of the matrix to be given separately. However, this is challenging when n is very high, so to make things more clear lets say I have a import numpy as np a = np.random.rand(3,2,2) array([[[ 0.33599705, 0.92803544], [ 0.6087729 , 0.8557143 ]], [[ 0.81496749, 0.15694689], [ 0.87476697, 0.67761456]], [[ 0.11375185, 0.32927167], [ 0.3456032 , 0.48672131]]]) what I want to achieve is something the same as from scipy.linalg import block_diag block_diag(a[0], a[1],a[2]) array([[ 0.33599705, 0.92803544, 0. , 0. , 0. , 0. ], [ 0.6087729 , 0.8557143 , 0. , 0. , 0. , 0. ], [ 0. , 0. , 0.81496749, 0.15694689, 0. , 0. ], [ 0. , 0. , 0.87476697, 0.67761456, 0. , 0. ], [ 0. , 0. , 0. , 0. , 0.11375185, 0.32927167], [ 0. , 0. , 0. , 0. , 0.3456032 , 0.48672131]]) This is just as an example in actual case a has hundreds of elements. A: <code> import numpy as np from scipy.linalg import block_diag np.random.seed(10) a = np.random.rand(100,2,2) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = block_diag(*a)

import numpy as np import copy from scipy.linalg import block_diag def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) a = np.random.rand(100, 2, 2) elif test_case_id == 2: np.random.seed(20) a = np.random.rand(10, 3, 3) return a def generate_ans(data): _a = data a = _a result = block_diag(*a) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np from scipy.linalg import block_diag a = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have the following code to run Wilcoxon rank-sum test print stats.ranksums(pre_course_scores, during_course_scores) RanksumsResult(statistic=8.1341352369246582, pvalue=4.1488919597127145e-16) However, I am interested in extracting the pvalue from the result. I could not find a tutorial about this. i.e.Given two ndarrays, pre_course_scores, during_course_scores, I want to know the pvalue of ranksum. Can someone help? A: <code> import numpy as np from scipy import stats np.random.seed(10) pre_course_scores = np.random.randn(10) during_course_scores = np.random.randn(10) </code> p_value = ... # put solution in this variable BEGIN SOLUTION <code>

p_value = stats.ranksums(pre_course_scores, during_course_scores).pvalue

import numpy as np import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) A = np.random.randn(10) B = np.random.randn(10) return A, B def generate_ans(data): _a = data pre_course_scores, during_course_scores = _a p_value = stats.ranksums(pre_course_scores, during_course_scores).pvalue return p_value test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert abs(result - ans) <= 1e-5 return 1 exec_context = r""" import numpy as np from scipy import stats pre_course_scores, during_course_scores = test_input [insert] result = p_value """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have the following code to run Wilcoxon rank-sum test print stats.ranksums(pre_course_scores, during_course_scores) RanksumsResult(statistic=8.1341352369246582, pvalue=4.1488919597127145e-16) However, I am interested in extracting the pvalue from the result. I could not find a tutorial about this. i.e.Given two ndarrays, pre_course_scores, during_course_scores, I want to know the pvalue of ranksum. Can someone help? A: <code> import numpy as np from scipy import stats example_pre_course_scores = np.random.randn(10) example_during_course_scores = np.random.randn(10) def f(pre_course_scores = example_pre_course_scores, during_course_scores = example_during_course_scores): # return the solution in this function # p_value = f(pre_course_scores, during_course_scores) ### BEGIN SOLUTION

p_value = stats.ranksums(pre_course_scores, during_course_scores).pvalue return p_value

import numpy as np import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) A = np.random.randn(10) B = np.random.randn(10) return A, B def generate_ans(data): _a = data pre_course_scores, during_course_scores = _a p_value = stats.ranksums(pre_course_scores, during_course_scores).pvalue return p_value test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert abs(result - ans) <= 1e-5 return 1 exec_context = r""" import numpy as np from scipy import stats def f(pre_course_scores, during_course_scores): [insert] pre_course_scores, during_course_scores = test_input result = f(pre_course_scores, during_course_scores) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: How to calculate kurtosis (the fourth standardized moment, according to Pearson’s definition) without bias correction? I have tried scipy.stats.kurtosis, but it gives a different result. I followed the definition in mathworld. A: <code> import numpy as np a = np.array([ 1. , 2. , 2.5, 400. , 6. , 0. ]) </code> kurtosis_result = ... # put solution in this variable BEGIN SOLUTION <code>

kurtosis_result = (sum((a - np.mean(a)) ** 4)/len(a)) / np.std(a)**4

import numpy as np import copy def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: a = np.array([1.0, 2.0, 2.5, 400.0, 6.0, 0.0]) elif test_case_id == 2: np.random.seed(42) a = np.random.randn(10) return a def generate_ans(data): _a = data a = _a kurtosis_result = (sum((a - np.mean(a)) ** 4) / len(a)) / np.std(a) ** 4 return kurtosis_result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np a = test_input [insert] result = kurtosis_result """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: How to calculate kurtosis (according to Fisher’s definition) without bias correction? A: <code> import numpy as np import scipy.stats a = np.array([ 1. , 2. , 2.5, 400. , 6. , 0. ]) </code> kurtosis_result = ... # put solution in this variable BEGIN SOLUTION <code>

kurtosis_result = scipy.stats.kurtosis(a)

import numpy as np import copy import scipy.stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: a = np.array([1.0, 2.0, 2.5, 400.0, 6.0, 0.0]) elif test_case_id == 2: np.random.seed(42) a = np.random.randn(10) return a def generate_ans(data): _a = data a = _a kurtosis_result = scipy.stats.kurtosis(a) return kurtosis_result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.stats a = test_input [insert] result = kurtosis_result """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a table of measured values for a quantity that depends on two parameters. So say I have a function fuelConsumption(speed, temperature), for which data on a mesh are known. Now I want to interpolate the expected fuelConsumption for a lot of measured data points (speed, temperature) from a pandas.DataFrame (and return a vector with the values for each data point). I am currently using SciPy's interpolate.interp2d for cubic interpolation, but when passing the parameters as two vectors [s1,s2] and [t1,t2] (only two ordered values for simplicity) it will construct a mesh and return: [[f(s1,t1), f(s2,t1)], [f(s1,t2), f(s2,t2)]] The result I am hoping to get is: [f(s1,t1), f(s2, t2)] How can I interpolate to get the output I want? I want to use function interpolated on x, y, z to compute values on arrays s and t, and the result should be like mentioned above. A: <code> import numpy as np import scipy.interpolate s = np.linspace(-1, 1, 50) t = np.linspace(-2, 0, 50) x, y = np.ogrid[-1:1:10j,-2:0:10j] z = (x + y)*np.exp(-6.0 * (x * x + y * y)) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

spl = scipy.interpolate.RectBivariateSpline(x, y, z) result = spl(s, t, grid=False)

import numpy as np import copy import scipy.interpolate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: s = np.linspace(-1, 1, 50) t = np.linspace(-2, 0, 50) return s, t def generate_ans(data): _a = data s, t = _a x, y = np.ogrid[-1:1:10j, -2:0:10j] z = (x + y) * np.exp(-6.0 * (x * x + y * y)) spl = scipy.interpolate.RectBivariateSpline(x, y, z) result = spl(s, t, grid=False) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.interpolate s, t = test_input x, y = np.ogrid[-1:1:10j,-2:0:10j] z = (x + y)*np.exp(-6.0 * (x * x + y * y)) [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a table of measured values for a quantity that depends on two parameters. So say I have a function fuelConsumption(speed, temperature), for which data on a mesh are known. Now I want to interpolate the expected fuelConsumption for a lot of measured data points (speed, temperature) from a pandas.DataFrame (and return a vector with the values for each data point). I am currently using SciPy's interpolate.interp2d for cubic interpolation, but when passing the parameters as two vectors [s1,s2] and [t1,t2] (only two ordered values for simplicity) it will construct a mesh and return: [[f(s1,t1), f(s2,t1)], [f(s1,t2), f(s2,t2)]] The result I am hoping to get is: [f(s1,t1), f(s2, t2)] How can I interpolate to get the output I want? I want to use function interpolated on x, y, z to compute values on arrays s and t, and the result should be like mentioned above. A: <code> import numpy as np import scipy.interpolate exampls_s = np.linspace(-1, 1, 50) example_t = np.linspace(-2, 0, 50) def f(s = example_s, t = example_t): x, y = np.ogrid[-1:1:10j,-2:0:10j] z = (x + y)*np.exp(-6.0 * (x * x + y * y)) # return the solution in this function # result = f(s, t) ### BEGIN SOLUTION

spl = scipy.interpolate.RectBivariateSpline(x, y, z) result = spl(s, t, grid=False) return result

import numpy as np import copy import scipy.interpolate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: s = np.linspace(-1, 1, 50) t = np.linspace(-2, 0, 50) return s, t def generate_ans(data): _a = data s, t = _a x, y = np.ogrid[-1:1:10j, -2:0:10j] z = (x + y) * np.exp(-6.0 * (x * x + y * y)) spl = scipy.interpolate.RectBivariateSpline(x, y, z) result = spl(s, t, grid=False) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.interpolate s, t = test_input def f(s, t): x, y = np.ogrid[-1:1:10j,-2:0:10j] z = (x + y)*np.exp(-6.0 * (x * x + y * y)) [insert] result = f(s, t) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I think my questions has something in common with this question or others, but anyway, mine is not specifically about them. I would like, after having found the voronoi tessallination for certain points, be able to check where other given points sit within the tessellination. In particular: Given say 50 extra-points, I want to be able to count how many of these extra points each voronoi cell contains. My MWE from scipy.spatial import ConvexHull, Voronoi points = [[0,0], [1,4], [2,3], [4,1], [1,1], [2,2], [5,3]] #voronoi vor = Voronoi(points) Now I am given extra points extraPoints = [[0.5,0.2], [3, 0], [4,0],[5,0], [4,3]] # In this case we have that the first point is in the bottom left, # the successive three are in the bottom right and the last one # is in the top right cell. I was thinking to use the fact that you can get vor.regions or vor.vertices, however I really couldn't come up with anything.. Is there parameter or a way to make this? The result I want is an np.array containing indices standing for regions occupied by different points, i.e., 1 for [1, 4]’s region. A: <code> import scipy.spatial points = [[0,0], [1,4], [2,3], [4,1], [1,1], [2,2], [5,3]] vor = scipy.spatial.Voronoi(points) extraPoints = [[0.5,0.2], [3, 0], [4,0],[5,0], [4,3]] </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

kdtree = scipy.spatial.cKDTree(points) _, result = kdtree.query(extraPoints)

import numpy as np import copy import scipy.spatial def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: points = [[0, 0], [1, 4], [2, 3], [4, 1], [1, 1], [2, 2], [5, 3]] extraPoints = [[0.5, 0.2], [3, 0], [4, 0], [5, 0], [4, 3]] elif test_case_id == 2: np.random.seed(42) points = (np.random.rand(15, 2) - 0.5) * 100 extraPoints = (np.random.rand(10, 2) - 0.5) * 100 return points, extraPoints def generate_ans(data): _a = data points, extraPoints = _a kdtree = scipy.spatial.cKDTree(points) _, result = kdtree.query(extraPoints) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import scipy.spatial points, extraPoints = test_input vor = scipy.spatial.Voronoi(points) [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I think my questions has something in common with this question or others, but anyway, mine is not specifically about them. I would like, after having found the voronoi tessallination for certain points, be able to check where other given points sit within the tessellination. In particular: Given say 50 extra-points, I want to be able to count how many of these extra points each voronoi cell contains. My MWE from scipy.spatial import ConvexHull, Voronoi points = [[0,0], [1,4], [2,3], [4,1], [1,1], [2,2], [5,3]] #voronoi vor = Voronoi(points) Now I am given extra points extraPoints = [[0.5,0.2], [3, 0], [4,0],[5,0], [4,3]] # In this case we have that the first point is in the bottom left, # the successive three are in the bottom right and the last one # is in the top right cell. I was thinking to use the fact that you can get vor.regions or vor.vertices, however I really couldn't come up with anything.. Is there parameter or a way to make this? The result I want is an np.array containing indices standing for regions occupied by different points, and that should be defined by Voronoi cell. A: <code> import scipy.spatial points = [[0,0], [1,4], [2,3], [4,1], [1,1], [2,2], [5,3]] vor = scipy.spatial.Voronoi(points) extraPoints = [[0.5,0.2], [3, 0], [4,0],[5,0], [4,3]] </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

kdtree = scipy.spatial.cKDTree(points) _, index = kdtree.query(extraPoints) result = vor.point_region[index]

import numpy as np import copy import scipy.spatial def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: points = [[0, 0], [1, 4], [2, 3], [4, 1], [1, 1], [2, 2], [5, 3]] extraPoints = [[0.5, 0.2], [3, 0], [4, 0], [5, 0], [4, 3]] elif test_case_id == 2: np.random.seed(42) points = (np.random.rand(15, 2) - 0.5) * 100 extraPoints = (np.random.rand(10, 2) - 0.5) * 100 return points, extraPoints def generate_ans(data): _a = data points, extraPoints = _a vor = scipy.spatial.Voronoi(points) kdtree = scipy.spatial.cKDTree(points) _, index = kdtree.query(extraPoints) result = vor.point_region[index] return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import scipy.spatial points, extraPoints = test_input vor = scipy.spatial.Voronoi(points) [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a list of numpy vectors of the format: [array([[-0.36314615, 0.80562619, -0.82777381, ..., 2.00876354,2.08571887, -1.24526026]]), array([[ 0.9766923 , -0.05725135, -0.38505339, ..., 0.12187988,-0.83129255, 0.32003683]]), array([[-0.59539878, 2.27166874, 0.39192573, ..., -0.73741573,1.49082653, 1.42466276]])] here, only 3 vectors in the list are shown. I have 100s.. The maximum number of elements in one vector is around 10 million All the arrays in the list have unequal number of elements but the maximum number of elements is fixed. Is it possible to create a sparse matrix using these vectors in python such that I have padded zeros to the end of elements for the vectors which are smaller than the maximum size? A: <code> import numpy as np import scipy.sparse as sparse np.random.seed(10) max_vector_size = 1000 vectors = [np.random.randint(100,size=900),np.random.randint(100,size=max_vector_size),np.random.randint(100,size=950)] </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = sparse.lil_matrix((len(vectors), max_vector_size)) for i, v in enumerate(vectors): result[i, :v.size] = v

import numpy as np import copy import scipy.sparse as sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(10) max_vector_size = 1000 vectors = [ np.random.randint(100, size=900), np.random.randint(100, size=max_vector_size), np.random.randint(100, size=950), ] elif test_case_id == 2: np.random.seed(42) max_vector_size = 300 vectors = [ np.random.randint(200, size=200), np.random.randint(200, size=max_vector_size), np.random.randint(200, size=200), np.random.randint(200, size=max_vector_size), np.random.randint(200, size=200), ] return vectors, max_vector_size def generate_ans(data): _a = data vectors, max_vector_size = _a result = sparse.lil_matrix((len(vectors), max_vector_size)) for i, v in enumerate(vectors): result[i, : v.size] = v return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert len(sparse.find(result != ans)[0]) == 0 return 1 exec_context = r""" import numpy as np import scipy.sparse as sparse vectors, max_vector_size = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a binary array, say, a = np.random.binomial(n=1, p=1/2, size=(9, 9)). I perform median filtering on it using a 3 x 3 kernel on it, like say, b = nd.median_filter(a, 3). I would expect that this should perform median filter based on the pixel and its eight neighbours. However, I am not sure about the placement of the kernel. The documentation says, origin : scalar, optional. The origin parameter controls the placement of the filter. Default 0.0. Now, I want to shift this filter one cell to the right.How can I achieve it? Thanks. A: <code> import numpy as np import scipy.ndimage a= np.zeros((5, 5)) a[1:4, 1:4] = np.arange(3*3).reshape((3, 3)) </code> b = ... # put solution in this variable BEGIN SOLUTION <code>

b = scipy.ndimage.median_filter(a, size=(3, 3), origin=(0, 1))

import numpy as np import copy import scipy.ndimage def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: a = np.zeros((5, 5)) a[1:4, 1:4] = np.arange(3 * 3).reshape((3, 3)) return a def generate_ans(data): _a = data a = _a b = scipy.ndimage.median_filter(a, size=(3, 3), origin=(0, 1)) return b test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np import scipy.ndimage a = test_input [insert] result = b """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have a sparse matrix in csr format (which makes sense for my purposes, as it has lots of rows but relatively few columns, ~8million x 90). My question is, what's the most efficient way to access a particular value from the matrix given a row,column tuple? I can quickly get a row using matrix.getrow(row), but this also returns 1-row sparse matrix, and accessing the value at a particular column seems clunky. The only reliable method I've found to get a particular matrix value, given the row and column, is: getting the row vector, converting to dense array, and fetching the element on column. But this seems overly verbose and complicated. and I don't want to change it to dense matrix to keep the efficiency. Is there a simpler/faster method I'm missing? A: <code> import numpy as np from scipy.sparse import csr_matrix arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]) M = csr_matrix(arr) row = 2 column = 3 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = M[row,column]

import numpy as np import copy import tokenize, io from scipy.sparse import csr_matrix def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: arr = np.array( [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] ) row = 2 column = 3 elif test_case_id == 2: np.random.seed(42) arr = np.random.randint(0, 3, (10, 10)) row = np.random.randint(0, 8) column = np.random.randint(0, 8) M = csr_matrix(arr) return M, row, column def generate_ans(data): _a = data M, row, column = _a result = M[row, column] return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np from scipy.sparse import csr_matrix M, row, column = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert ( "toarray" not in tokens and "array" not in tokens and "todense" not in tokens and "A" not in tokens )

Problem: I have a sparse matrix in csr format (which makes sense for my purposes, as it has lots of rows but relatively few columns, ~8million x 90). My question is, what's the most efficient way to access particular values from the matrix given lists of row,column indices? I can quickly get a row using matrix.getrow(row), but this also returns 1-row sparse matrix, and accessing the value at a particular column seems clunky. The only reliable method I've found to get a particular matrix value, given the row and column, is: getting the row vector, converting to dense array, and fetching the element on column. But this seems overly verbose and complicated. and I don't want to change it to dense matrix to keep the efficiency. for example, I want to fetch elements at (2, 3) and (1, 0), so row = [2, 1], and column = [3, 0]. The result should be a list or 1-d array like: [matirx[2, 3], matrix[1, 0]] Is there a simpler/faster method I'm missing? A: <code> import numpy as np from scipy.sparse import csr_matrix arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]) M = csr_matrix(arr) row = [2, 1] column = [3, 0] </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = np.array(M[row,column]).squeeze()

import numpy as np import copy import tokenize, io from scipy.sparse import csr_matrix def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: arr = np.array( [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] ) row = [2, 1] column = [3, 0] elif test_case_id == 2: np.random.seed(42) arr = np.random.randint(0, 3, (10, 10)) row = np.random.randint(0, 8, (2,)) column = np.random.randint(0, 8, (2,)) M = csr_matrix(arr) return M, row, column def generate_ans(data): _a = data M, row, column = _a result = np.array(M[row, column]).squeeze() return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np from scipy.sparse import csr_matrix M, row, column = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert "toarray" not in tokens and "todense" not in tokens and "A" not in tokens

Problem: I have an array which I want to interpolate over the 1st axes. At the moment I am doing it like this example: import numpy as np from scipy.interpolate import interp1d array = np.random.randint(0, 9, size=(100, 100, 100)) new_array = np.zeros((1000, 100, 100)) x = np.arange(0, 100, 1) x_new = np.arange(0, 100, 0.1) for i in x: for j in x: f = interp1d(x, array[:, i, j]) new_array[:, i, j] = f(xnew) The data I use represents 10 years of 5-day averaged values for each latitude and longitude in a domain. I want to create an array of daily values. I have also tried using splines. I don't really know how they work but it was not much faster. Is there a way to do this without using for loops? The result I want is an np.array of transformed x_new values using interpolated function. Thank you in advance for any suggestions. A: <code> import numpy as np import scipy.interpolate array = np.random.randint(0, 9, size=(10, 10, 10)) x = np.linspace(0, 10, 10) x_new = np.linspace(0, 10, 100) </code> new_array = ... # put solution in this variable BEGIN SOLUTION <code>

new_array = scipy.interpolate.interp1d(x, array, axis=0)(x_new)

import numpy as np import copy import tokenize, io import scipy.interpolate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(42) array = np.random.randint(0, 9, size=(10, 10, 10)) x = np.linspace(0, 10, 10) x_new = np.linspace(0, 10, 100) return x, array, x_new def generate_ans(data): _a = data x, array, x_new = _a new_array = scipy.interpolate.interp1d(x, array, axis=0)(x_new) return new_array test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == np.ndarray assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.interpolate x, array, x_new = test_input [insert] result = new_array """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert "while" not in tokens and "for" not in tokens

Problem: I'm trying to integrate X (X ~ N(u, o2)) to calculate the probability up to position `x`. However I'm running into an error of: Traceback (most recent call last): File "<ipython console>", line 1, in <module> File "siestats.py", line 349, in NormalDistro P_inner = scipy.integrate(NDfx,-dev,dev) TypeError: 'module' object is not callable My code runs this: # Definition of the mathematical function: def NDfx(x): return((1/math.sqrt((2*math.pi)))*(math.e**((-.5)*(x**2)))) # This Function normailizes x, u, and o2 (position of interest, mean and st dev) # and then calculates the probability up to position 'x' def NormalDistro(u,o2,x): dev = abs((x-u)/o2) P_inner = scipy.integrate(NDfx,-dev,dev) P_outer = 1 - P_inner P = P_inner + P_outer/2 return(P) A: <code> import scipy.integrate import math import numpy as np def NDfx(x): return((1/math.sqrt((2*math.pi)))*(math.e**((-.5)*(x**2)))) x = 2.5 u = 1 o2 = 3 </code> prob = ... # put solution in this variable BEGIN SOLUTION <code>

norm = (x-u)/o2 prob = scipy.integrate.quad(NDfx, -np.inf, norm)[0]

import numpy as np import math import copy import scipy.integrate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: x = 2.5 u = 1 o2 = 3 elif test_case_id == 2: x = -2.5 u = 2 o2 = 4 return x, u, o2 def generate_ans(data): _a = data def NDfx(x): return (1 / math.sqrt((2 * math.pi))) * (math.e ** ((-0.5) * (x**2))) x, u, o2 = _a norm = (x - u) / o2 prob = scipy.integrate.quad(NDfx, -np.inf, norm)[0] return prob test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import scipy.integrate import math import numpy as np x, u, o2 = test_input def NDfx(x): return((1/math.sqrt((2*math.pi)))*(math.e**((-.5)*(x**2)))) [insert] result = prob """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm trying to integrate X (X ~ N(u, o2)) to calculate the probability up to position `x`. However I'm running into an error of: Traceback (most recent call last): File "<ipython console>", line 1, in <module> File "siestats.py", line 349, in NormalDistro P_inner = scipy.integrate(NDfx,-dev,dev) TypeError: 'module' object is not callable My code runs this: # Definition of the mathematical function: def NDfx(x): return((1/math.sqrt((2*math.pi)))*(math.e**((-.5)*(x**2)))) # This Function normailizes x, u, and o2 (position of interest, mean and st dev) # and then calculates the probability up to position 'x' def NormalDistro(u,o2,x): dev = abs((x-u)/o2) P_inner = scipy.integrate(NDfx,-dev,dev) P_outer = 1 - P_inner P = P_inner + P_outer/2 return(P) A: <code> import scipy.integrate import math import numpy as np def NDfx(x): return((1/math.sqrt((2*math.pi)))*(math.e**((-.5)*(x**2)))) def f(x = 2.5, u = 1, o2 = 3): # return the solution in this function # prob = f(x, u, o2) ### BEGIN SOLUTION

norm = (x-u)/o2 prob = scipy.integrate.quad(NDfx, -np.inf, norm)[0] return prob

import numpy as np import math import copy import scipy.integrate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: x = 2.5 u = 1 o2 = 3 elif test_case_id == 2: x = -2.5 u = 2 o2 = 4 return x, u, o2 def generate_ans(data): _a = data def NDfx(x): return (1 / math.sqrt((2 * math.pi))) * (math.e ** ((-0.5) * (x**2))) x, u, o2 = _a norm = (x - u) / o2 prob = scipy.integrate.quad(NDfx, -np.inf, norm)[0] return prob test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import scipy.integrate import math import numpy as np x, u, o2 = test_input def NDfx(x): return((1/math.sqrt((2*math.pi)))*(math.e**((-.5)*(x**2)))) def f(x, u, o2): [insert] result = f(x, u, o2) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: Using scipy, is there an easy way to emulate the behaviour of MATLAB's dctmtx function which returns a NxN (ortho-mode normed) DCT matrix for some given N? There's scipy.fftpack.dctn but that only applies the DCT. Do I have to implement this from scratch if I don't want use another dependency besides scipy? A: <code> import numpy as np import scipy.fft as sf N = 8 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = sf.dct(np.eye(N), axis=0, norm= 'ortho')

import numpy as np import copy import scipy.fft as sf def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: N = 8 elif test_case_id == 2: np.random.seed(42) N = np.random.randint(4, 15) return N def generate_ans(data): _a = data N = _a result = sf.dct(np.eye(N), axis=0, norm="ortho") return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.fft as sf N = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: Having difficulty generating a tridiagonal matrix from numpy arrays. I managed to replicate the results given here, but I'm not able to apply these techniques to my problem. I may also be misunderstanding the application of scipy.sparse.diag. For context, I'm working on a problem which requires the generation of a tridiagonal matrix to solve an ordinary differential equation numerically using finite differences. from scipy.sparse import diags import numpy as np v1 = [3*i**2 +(i/2) for i in range(1, 6)] v2 = [-(6*i**2 - 1) for i in range(1, 6)] v3 = [3*i**2 -(i/2) for i in range(1, 6)] matrix = np.array([v1, v2, v3]) matrix is equal to. array([[3.5, 13. , 28.5, 50. , 77.5], [-5. , -23. , -53. , -95. , -149. ], [2.5, 11. , 25.5, 46. , 72.5]]) After working through the Scipy documentation and the examples in the link above, I was expecting the following code to yield Tridiagonal_1, but instead get Tridiagonal_2. diags(matrix, [-1,0,1], (5, 5)).toarray() expected Tridiagonal_1: array([[ -5. , 2.5 , 0. , 0. , 0. ], [ 13. , -23. , 11. , 0. , 0. ], [ 0. , 28.5., -53. , 25.5, 0. ], [ 0. , 0. , 50 , -95., 46. ], [ 0. , 0. , 0. , 77.5., -149. ]]) Code yielded Tridiagonal_2: array([[ -5. , 2.5, 0. , 0. , 0. ], [ 3.5, -23. , 11. , 0. , 0. ], [ 0. , 13. , -53. , 25.5, 0. ], [ 0. , 0. , 28.5, -95. , 46. ], [ 0. , 0. , 0. , 50. , -149. ]]) I was expecting offset = [-1,0,1] to shift the diagonal entries to the left, but the first offset is shifting the first diag to the next row. Is this correct or is there an error in my code causing this behaviour? A: <code> from scipy import sparse import numpy as np matrix = np.array([[3.5, 13. , 28.5, 50. , 77.5], [-5. , -23. , -53. , -95. , -149. ], [2.5, 11. , 25.5, 46. , 72.5]]) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = sparse.spdiags(matrix, (1, 0, -1), 5, 5).T.A

import numpy as np import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: matrix = np.array( [ [3.5, 13.0, 28.5, 50.0, 77.5], [-5.0, -23.0, -53.0, -95.0, -149.0], [2.5, 11.0, 25.5, 46.0, 72.5], ] ) elif test_case_id == 2: np.random.seed(42) matrix = np.random.rand(3, 5) return matrix def generate_ans(data): _a = data matrix = _a result = sparse.spdiags(matrix, (1, 0, -1), 5, 5).T.A return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" from scipy import sparse import numpy as np matrix = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: Give the N and P, I want to get a 2D binomial distribution probability matrix M, for i in range(N+1): for j in range(i+1): M[i,j] = choose(i, j) * p**j * (1-p)**(i-j) other value = 0 I want to know is there any fast way to get this matrix, instead of the for loop. the N may be bigger than 100,000 A: <code> import numpy as np import scipy.stats N = 3 p = 0.5 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

n = np.arange(N + 1, dtype=np.int64) dist = scipy.stats.binom(p=p, n=n) result = dist.pmf(k=np.arange(N + 1, dtype=np.int64)[:, None]).T

import numpy as np import copy import tokenize, io import scipy.stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: N = 3 p = 0.5 elif test_case_id == 2: np.random.seed(234) N = np.random.randint(6, 10) p = 0.3 return N, p def generate_ans(data): _a = data N, p = _a n = np.arange(N + 1, dtype=np.int64) dist = scipy.stats.binom(p=p, n=n) result = dist.pmf(k=np.arange(N + 1, dtype=np.int64)[:, None]).T return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np import scipy.stats N, p = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert "while" not in tokens and "for" not in tokens

Problem: I have the following data frame: import pandas as pd import io from scipy import stats temp=u"""probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" df = pd.read_csv(io.StringIO(temp),index_col='probegenes') df It looks like this sample1 sample2 sample3 probegenes 1415777_at Pnliprp1 20 0 11 1415805_at Clps 17 0 55 1415884_at Cela3b 47 0 100 What I want to do is too perform row-zscore calculation using SCIPY. At the end of the day. the result will look like: sample1 sample2 sample3 probegenes 1415777_at Pnliprp1 1.18195176, -1.26346568, 0.08151391 1415805_at Clps -0.30444376, -1.04380717, 1.34825093 1415884_at Cela3b -0.04896043, -1.19953047, 1.2484909 A: <code> import pandas as pd import io from scipy import stats temp=u"""probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" df = pd.read_csv(io.StringIO(temp),index_col='probegenes') </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = pd.DataFrame(data=stats.zscore(df, axis = 1), index=df.index, columns=df.columns)

import pandas as pd import io import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: temp = """probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" elif test_case_id == 2: temp = """probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,2.00,11 1415805_at Clps,17,0.30,55 1415884_at Cela3b,47,1.00,100""" df = pd.read_csv(io.StringIO(temp), index_col="probegenes") return df def generate_ans(data): _a = data df = _a result = pd.DataFrame( data=stats.zscore(df, axis=1), index=df.index, columns=df.columns ) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): pd.testing.assert_frame_equal(result, ans, check_dtype=False) return 1 exec_context = r""" import pandas as pd import io from scipy import stats df = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have the following data frame: import pandas as pd import io from scipy import stats temp=u"""probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" df = pd.read_csv(io.StringIO(temp),index_col='probegenes') df It looks like this sample1 sample2 sample3 probegenes 1415777_at Pnliprp1 20 0 11 1415805_at Clps 17 0 55 1415884_at Cela3b 47 0 100 What I want to do is too perform column-zscore calculation using SCIPY. At the end of the day. the result will look like: sample1 sample2 sample3 probegenes 1415777_at Pnliprp1 x.xxxxxxxx, x.xxxxxxxx, x.xxxxxxxx 1415805_at Clps x.xxxxxxxx, x.xxxxxxxx, x.xxxxxxxx 1415884_at Cela3b x.xxxxxxxx, x.xxxxxxxx, x.xxxxxxxx A: <code> import pandas as pd import io from scipy import stats temp=u"""probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" df = pd.read_csv(io.StringIO(temp),index_col='probegenes') </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = pd.DataFrame(data=stats.zscore(df, axis = 0), index=df.index, columns=df.columns)

import pandas as pd import io import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: temp = """probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" elif test_case_id == 2: temp = """probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,2.00,11 1415805_at Clps,17,0.30,55 1415884_at Cela3b,47,1.00,100""" df = pd.read_csv(io.StringIO(temp), index_col="probegenes") return df def generate_ans(data): _a = data df = _a result = pd.DataFrame( data=stats.zscore(df, axis=0), index=df.index, columns=df.columns ) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): pd.testing.assert_frame_equal(result, ans, check_dtype=False) return 1 exec_context = r""" import pandas as pd import io from scipy import stats df = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have the following data frame: import pandas as pd import io from scipy import stats temp=u"""probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" df = pd.read_csv(io.StringIO(temp),index_col='probegenes') df It looks like this sample1 sample2 sample3 probegenes 1415777_at Pnliprp1 20 0 11 1415805_at Clps 17 0 55 1415884_at Cela3b 47 0 100 What I want to do is too perform row-zscore calculation using SCIPY. AND I want to show data and zscore together in a single dataframe. At the end of the day. the result will look like: sample1 sample2 sample3 probegenes 1415777_at Pnliprp1 data 20 0 11 zscore 1.18195176 -1.26346568 0.08151391 1415805_at Clps data 17 0 55 zscore -0.30444376 -1.04380717 1.34825093 1415884_at Cela3b data 47 0 100 zscore -0.04896043 -1.19953047 1.2484909 A: <code> import pandas as pd import io from scipy import stats temp=u"""probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" df = pd.read_csv(io.StringIO(temp),index_col='probegenes') </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

indices = [('1415777_at Pnliprp1', 'data'), ('1415777_at Pnliprp1', 'zscore'), ('1415805_at Clps', 'data'), ('1415805_at Clps', 'zscore'), ('1415884_at Cela3b', 'data'), ('1415884_at Cela3b', 'zscore')] indices = pd.MultiIndex.from_tuples(indices) df2 = pd.DataFrame(data=stats.zscore(df, axis = 1), index=df.index, columns=df.columns) df3 = pd.concat([df, df2], axis=1).to_numpy().reshape(-1, 3) result = pd.DataFrame(data=df3, index=indices, columns=df.columns)

import pandas as pd import io import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: temp = """probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" elif test_case_id == 2: temp = """probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,2.00,11 1415805_at Clps,17,0.30,55 1415884_at Cela3b,47,1.00,100""" df = pd.read_csv(io.StringIO(temp), index_col="probegenes") return df def generate_ans(data): _a = data df = _a indices = [ ("1415777_at Pnliprp1", "data"), ("1415777_at Pnliprp1", "zscore"), ("1415805_at Clps", "data"), ("1415805_at Clps", "zscore"), ("1415884_at Cela3b", "data"), ("1415884_at Cela3b", "zscore"), ] indices = pd.MultiIndex.from_tuples(indices) df2 = pd.DataFrame( data=stats.zscore(df, axis=1), index=df.index, columns=df.columns ) df3 = pd.concat([df, df2], axis=1).to_numpy().reshape(-1, 3) result = pd.DataFrame(data=df3, index=indices, columns=df.columns) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): pd.testing.assert_frame_equal(result, ans, check_dtype=False) return 1 exec_context = r""" import pandas as pd import io from scipy import stats df = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have the following data frame: import pandas as pd import io from scipy import stats temp=u"""probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" df = pd.read_csv(io.StringIO(temp),index_col='probegenes') df It looks like this sample1 sample2 sample3 probegenes 1415777_at Pnliprp1 20 0 11 1415805_at Clps 17 0 55 1415884_at Cela3b 47 0 100 What I want to do is too perform column-zscore calculation using SCIPY. AND I want to show data and zscore together in a single dataframe. For each element, I want to only keep 3 decimals places. At the end of the day. the result will look like: sample1 sample2 sample3 probegenes 1415777_at Pnliprp1 data 20.000 0.000 11.000 zscore -0.593 NaN -1.220 1415805_at Clps data 17.000 0.000 55.000 zscore -0.815 NaN -0.009 1415884_at Cela3b data 47.000 0.000 100.000 zscore 1.408 NaN 1.229 A: <code> import pandas as pd import io import numpy as np from scipy import stats temp=u"""probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" df = pd.read_csv(io.StringIO(temp),index_col='probegenes') </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

indices = [('1415777_at Pnliprp1', 'data'), ('1415777_at Pnliprp1', 'zscore'), ('1415805_at Clps', 'data'), ('1415805_at Clps', 'zscore'), ('1415884_at Cela3b', 'data'), ('1415884_at Cela3b', 'zscore')] indices = pd.MultiIndex.from_tuples(indices) df2 = pd.DataFrame(data=stats.zscore(df, axis = 0), index=df.index, columns=df.columns) df3 = pd.concat([df, df2], axis=1).to_numpy().reshape(-1, 3) result = pd.DataFrame(data=np.round(df3, 3), index=indices, columns=df.columns)

import numpy as np import pandas as pd import io import copy from scipy import stats def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: temp = """probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,0.00,11 1415805_at Clps,17,0.00,55 1415884_at Cela3b,47,0.00,100""" elif test_case_id == 2: temp = """probegenes,sample1,sample2,sample3 1415777_at Pnliprp1,20,2.00,11 1415805_at Clps,17,0.30,55 1415884_at Cela3b,47,1.00,100""" df = pd.read_csv(io.StringIO(temp), index_col="probegenes") return df def generate_ans(data): _a = data df = _a indices = [ ("1415777_at Pnliprp1", "data"), ("1415777_at Pnliprp1", "zscore"), ("1415805_at Clps", "data"), ("1415805_at Clps", "zscore"), ("1415884_at Cela3b", "data"), ("1415884_at Cela3b", "zscore"), ] indices = pd.MultiIndex.from_tuples(indices) df2 = pd.DataFrame( data=stats.zscore(df, axis=0), index=df.index, columns=df.columns ) df3 = pd.concat([df, df2], axis=1).to_numpy().reshape(-1, 3) result = pd.DataFrame(data=np.round(df3, 3), index=indices, columns=df.columns) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): pd.testing.assert_frame_equal(result, ans, atol=1e-3, check_dtype=False) return 1 exec_context = r""" import pandas as pd import io import numpy as np from scipy import stats df = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm searching for examples of using scipy.optimize.line_search. I do not really understand how this function works with multivariable functions. I wrote a simple example import scipy as sp import scipy.optimize def test_func(x): return (x[0])**2+(x[1])**2 def test_grad(x): return [2*x[0],2*x[1]] sp.optimize.line_search(test_func,test_grad,[1.8,1.7],[-1.0,-1.0]) And I've got File "D:\Anaconda2\lib\site-packages\scipy\optimize\linesearch.py", line 259, in phi return f(xk + alpha * pk, *args) TypeError: can't multiply sequence by non-int of type 'float' The result should be the alpha value of line_search A: <code> import scipy import scipy.optimize import numpy as np def test_func(x): return (x[0])**2+(x[1])**2 def test_grad(x): return [2*x[0],2*x[1]] starting_point = [1.8, 1.7] direction = [-1, -1] </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = scipy.optimize.line_search(test_func, test_grad, np.array(starting_point), np.array(direction))[0]

import numpy as np import copy import scipy.optimize def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: starting_point = [1.8, 1.7] direction = [-1, -1] elif test_case_id == 2: starting_point = [50, 37] direction = [-1, -1] return starting_point, direction def generate_ans(data): _a = data def test_func(x): return (x[0]) ** 2 + (x[1]) ** 2 def test_grad(x): return [2 * x[0], 2 * x[1]] starting_point, direction = _a result = scipy.optimize.line_search( test_func, test_grad, np.array(starting_point), np.array(direction) )[0] return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert abs(result - ans) <= 1e-5 return 1 exec_context = r""" import scipy import scipy.optimize import numpy as np def test_func(x): return (x[0])**2+(x[1])**2 def test_grad(x): return [2*x[0],2*x[1]] starting_point, direction = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm trying to create a 2-dimensional array in Scipy/Numpy where each value represents the euclidean distance from the center. I'm very new to Scipy, and would like to know if there's a more elegant, idiomatic way of doing the same thing. I found the scipy.spatial.distance.cdist function, which seems promising, but I'm at a loss regarding how to fit it into this problem. def get_distance_2(y, x): mid = ... # needs to be a array of the shape (rows, cols, 2)? return scipy.spatial.distance.cdist(scipy.dstack((y, x)), mid) Just to clarify, what I'm looking for is something like this (for a 6 x 6 array). That is, to compute (Euclidean) distances from center point to every point in the image. [[ 3.53553391 2.91547595 2.54950976 2.54950976 2.91547595 3.53553391] [ 2.91547595 2.12132034 1.58113883 1.58113883 2.12132034 2.91547595] [ 2.54950976 1.58113883 0.70710678 0.70710678 1.58113883 2.54950976] [ 2.54950976 1.58113883 0.70710678 0.70710678 1.58113883 2.54950976] [ 2.91547595 2.12132034 1.58113883 1.58113883 2.12132034 2.91547595] [ 3.53553391 2.91547595 2.54950976 2.54950976 2.91547595 3.53553391]] A: <code> import numpy as np from scipy.spatial import distance shape = (6, 6) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

xs, ys = np.indices(shape) xs = xs.reshape(shape[0] * shape[1], 1) ys = ys.reshape(shape[0] * shape[1], 1) X = np.hstack((xs, ys)) mid_x, mid_y = (shape[0]-1)/2.0, (shape[1]-1)/2.0 result = distance.cdist(X, np.atleast_2d([mid_x, mid_y])).reshape(shape)

import numpy as np import copy from scipy.spatial import distance def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: shape = (6, 6) elif test_case_id == 2: shape = (10, 3) elif test_case_id == 3: np.random.seed(42) shape = np.random.randint(2, 15, (2,)) return shape def generate_ans(data): _a = data shape = _a xs, ys = np.indices(shape) xs = xs.reshape(shape[0] * shape[1], 1) ys = ys.reshape(shape[0] * shape[1], 1) X = np.hstack((xs, ys)) mid_x, mid_y = (shape[0] - 1) / 2.0, (shape[1] - 1) / 2.0 result = distance.cdist(X, np.atleast_2d([mid_x, mid_y])).reshape(shape) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np from scipy.spatial import distance shape = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(3): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm trying to create a 2-dimensional array in Scipy/Numpy where each value represents the Manhattan distance from the center. It's supposed to have the same shape as the first two dimensions of a 3-dimensional array (an image, created via scipy.misc.fromimage). I'm very new to Scipy, and would like to know if there's a more elegant, idiomatic way of doing the same thing. I found the scipy.spatial.distance.cdist function, which seems promising, but I'm at a loss regarding how to fit it into this problem. def get_distance_2(y, x): mid = ... # needs to be a array of the shape (rows, cols, 2)? return scipy.spatial.distance.cdist(scipy.dstack((y, x)), mid) Just to clarify, what I'm looking for is something like this (for a 6 x 6 array). That is, to compute Manhattan distances from center point to every point in the image. [[5., 4., 3., 3., 4., 5.], [4., 3., 2., 2., 3., 4.], [3., 2., 1., 1., 2., 3.], [3., 2., 1., 1., 2., 3.], [4., 3., 2., 2., 3., 4.], [5., 4., 3., 3., 4., 5.]] A: <code> import numpy as np from scipy.spatial import distance shape = (6, 6) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

xs, ys = np.indices(shape) xs = xs.reshape(shape[0] * shape[1], 1) ys = ys.reshape(shape[0] * shape[1], 1) X = np.hstack((xs, ys)) mid_x, mid_y = (shape[0]-1)/2.0, (shape[1]-1)/2.0 result = distance.cdist(X, np.atleast_2d([mid_x, mid_y]), 'minkowski', p=1).reshape(shape)

import numpy as np import copy from scipy.spatial import distance def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: shape = (6, 6) elif test_case_id == 2: shape = (10, 3) elif test_case_id == 3: np.random.seed(42) shape = np.random.randint(2, 15, (2,)) return shape def generate_ans(data): _a = data shape = _a xs, ys = np.indices(shape) xs = xs.reshape(shape[0] * shape[1], 1) ys = ys.reshape(shape[0] * shape[1], 1) X = np.hstack((xs, ys)) mid_x, mid_y = (shape[0] - 1) / 2.0, (shape[1] - 1) / 2.0 result = distance.cdist( X, np.atleast_2d([mid_x, mid_y]), "minkowski", p=1 ).reshape(shape) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np from scipy.spatial import distance shape = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(3): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm trying to create a 2-dimensional array in Scipy/Numpy where each value represents the euclidean distance from the center. It's supposed to have the same shape as the first two dimensions of a 3-dimensional array (an image, created via scipy.misc.fromimage). I'm very new to Scipy, and would like to know if there's a more elegant, idiomatic way of doing the same thing. I found the scipy.spatial.distance.cdist function, which seems promising, but I'm at a loss regarding how to fit it into this problem. def get_distance_2(y, x): mid = ... # needs to be a array of the shape (rows, cols, 2)? return scipy.spatial.distance.cdist(scipy.dstack((y, x)), mid) Just to clarify, what I'm looking for is something like this (for a 6 x 6 array). That is, to compute (Euclidean) distances from center point to every point in the image. [[ 3.53553391 2.91547595 2.54950976 2.54950976 2.91547595 3.53553391] [ 2.91547595 2.12132034 1.58113883 1.58113883 2.12132034 2.91547595] [ 2.54950976 1.58113883 0.70710678 0.70710678 1.58113883 2.54950976] [ 2.54950976 1.58113883 0.70710678 0.70710678 1.58113883 2.54950976] [ 2.91547595 2.12132034 1.58113883 1.58113883 2.12132034 2.91547595] [ 3.53553391 2.91547595 2.54950976 2.54950976 2.91547595 3.53553391]] A: <code> import numpy as np from scipy.spatial import distance def f(shape = (6, 6)): # return the solution in this function # result = f(shape = (6, 6)) ### BEGIN SOLUTION

xs, ys = np.indices(shape) xs = xs.reshape(shape[0] * shape[1], 1) ys = ys.reshape(shape[0] * shape[1], 1) X = np.hstack((xs, ys)) mid_x, mid_y = (shape[0]-1)/2.0, (shape[1]-1)/2.0 result = distance.cdist(X, np.atleast_2d([mid_x, mid_y])).reshape(shape) return result

import numpy as np import copy from scipy.spatial import distance def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: shape = (6, 6) elif test_case_id == 2: shape = (10, 3) elif test_case_id == 3: np.random.seed(42) shape = np.random.randint(2, 15, (2,)) return shape def generate_ans(data): _a = data shape = _a xs, ys = np.indices(shape) xs = xs.reshape(shape[0] * shape[1], 1) ys = ys.reshape(shape[0] * shape[1], 1) X = np.hstack((xs, ys)) mid_x, mid_y = (shape[0] - 1) / 2.0, (shape[1] - 1) / 2.0 result = distance.cdist(X, np.atleast_2d([mid_x, mid_y])).reshape(shape) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np from scipy.spatial import distance shape = test_input def f(shape = (6, 6)): [insert] result = f(shape) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(3): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I would like to resample a numpy array as suggested here Resampling a numpy array representing an image however this resampling will do so by a factor i.e. x = np.arange(9).reshape(3,3) print scipy.ndimage.zoom(x, 2, order=1) Will create a shape of (6,6) but how can I resample an array to its best approximation within a (4,6),(6,8) or (6,10) shape for instance? A: <code> import numpy as np import scipy.ndimage x = np.arange(9).reshape(3, 3) shape = (6, 8) </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = scipy.ndimage.zoom(x, zoom=(shape[0]/x.shape[0], shape[1]/x.shape[1]), order=1)

import numpy as np import copy import scipy.ndimage def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: shape = (6, 8) elif test_case_id == 2: shape = (6, 10) elif test_case_id == 3: shape = (4, 6) elif test_case_id == 4: np.random.seed(42) shape = np.random.randint(4, 20, (2,)) x = np.arange(9).reshape(3, 3) return x, shape def generate_ans(data): _a = data x, shape = _a result = scipy.ndimage.zoom( x, zoom=(shape[0] / x.shape[0], shape[1] / x.shape[1]), order=1 ) return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_array_equal(result, ans) return 1 exec_context = r""" import numpy as np import scipy.ndimage x, shape = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(4): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I am having a problem with minimization procedure. Actually, I could not create a correct objective function for my problem. Problem definition • My function: yn = a_11*x1**2 + a_12*x2**2 + ... + a_m*xn**2,where xn- unknowns, a_m - coefficients. n = 1..N, m = 1..M • In my case, N=5 for x1,..,x5 and M=3 for y1, y2, y3. I need to find the optimum: x1, x2,...,x5 so that it can satisfy the y My question: • How to solve the question using scipy.optimize? My code: (tried in lmfit, but return errors. Therefore I would ask for scipy solution) import numpy as np from lmfit import Parameters, minimize def func(x,a): return np.dot(a, x**2) def residual(pars, a, y): vals = pars.valuesdict() x = vals['x'] model = func(x,a) return (y - model) **2 def main(): # simple one: a(M,N) = a(3,5) a = np.array([ [ 0, 0, 1, 1, 1 ], [ 1, 0, 1, 0, 1 ], [ 0, 1, 0, 1, 0 ] ]) # true values of x x_true = np.array([10, 13, 5, 8, 40]) # data without noise y = func(x_true,a) #************************************ # Apriori x0 x0 = np.array([2, 3, 1, 4, 20]) fit_params = Parameters() fit_params.add('x', value=x0) out = minimize(residual, fit_params, args=(a, y)) print out if __name__ == '__main__': main() Result should be optimal x array. A: <code> import scipy.optimize import numpy as np np.random.seed(42) a = np.random.rand(3,5) x_true = np.array([10, 13, 5, 8, 40]) y = a.dot(x_true ** 2) x0 = np.array([2, 3, 1, 4, 20]) </code> out = ... # put solution in this variable BEGIN SOLUTION <code>

def residual_ans(x, a, y): s = ((y - a.dot(x**2))**2).sum() return s out = scipy.optimize.minimize(residual_ans, x0=x0, args=(a, y), method= 'L-BFGS-B').x

import numpy as np import copy def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(42) a = np.random.rand(3, 5) x_true = np.array([10, 13, 5, 8, 40]) y = a.dot(x_true**2) x0 = np.array([2, 3, 1, 4, 20]) elif test_case_id == 2: np.random.seed(42) a = np.random.rand(4, 6) x_true = np.array([-3, 2, 7, 18, 4, -1]) y = a.dot(x_true**2) x0 = np.array([2, 3, 1, 4, 2, 0]) return a, y, x0 def generate_ans(data): _a = data a, y, x0 = _a return a, y test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): a, y = ans def residual(x, a, y): s = ((y - a.dot(x**2)) ** 2).sum() return s assert residual(result, a, y) < 1e-5 return 1 exec_context = r""" import scipy.optimize import numpy as np a, y, x0 = test_input [insert] result = out """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I am having a problem with minimization procedure. Actually, I could not create a correct objective function for my problem. Problem definition • My function: yn = a_11*x1**2 + a_12*x2**2 + ... + a_m*xn**2,where xn- unknowns, a_m - coefficients. n = 1..N, m = 1..M • In my case, N=5 for x1,..,x5 and M=3 for y1, y2, y3. I need to find the optimum: x1, x2,...,x5 so that it can satisfy the y My question: • How to solve the question using scipy.optimize? My code: (tried in lmfit, but return errors. Therefore I would ask for scipy solution) import numpy as np from lmfit import Parameters, minimize def func(x,a): return np.dot(a, x**2) def residual(pars, a, y): vals = pars.valuesdict() x = vals['x'] model = func(x,a) return (y - model)**2 def main(): # simple one: a(M,N) = a(3,5) a = np.array([ [ 0, 0, 1, 1, 1 ], [ 1, 0, 1, 0, 1 ], [ 0, 1, 0, 1, 0 ] ]) # true values of x x_true = np.array([10, 13, 5, 8, 40]) # data without noise y = func(x_true,a) #************************************ # Apriori x0 x0 = np.array([2, 3, 1, 4, 20]) fit_params = Parameters() fit_params.add('x', value=x0) out = minimize(residual, fit_params, args=(a, y)) print out if __name__ == '__main__': main() Result should be optimal x array. The method I hope to use is L-BFGS-B, with added lower bounds on x. A: <code> import scipy.optimize import numpy as np np.random.seed(42) a = np.random.rand(3,5) x_true = np.array([10, 13, 5, 8, 40]) y = a.dot(x_true ** 2) x0 = np.array([2, 3, 1, 4, 20]) x_lower_bounds = x_true / 2 </code> out = ... # put solution in this variable BEGIN SOLUTION <code>

def residual_ans(x, a, y): s = ((y - a.dot(x**2))**2).sum() return s bounds = [[x, None] for x in x_lower_bounds] out = scipy.optimize.minimize(residual_ans, x0=x0, args=(a, y), method= 'L-BFGS-B', bounds=bounds).x

import numpy as np import copy import scipy.optimize def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: np.random.seed(42) a = np.random.rand(3, 5) x_true = np.array([10, 13, 5, 8, 40]) y = a.dot(x_true**2) x0 = np.array([2, 3, 1, 4, 20]) x_bounds = x_true / 2 return a, x_true, y, x0, x_bounds def generate_ans(data): _a = data a, x_true, y, x0, x_lower_bounds = _a def residual_ans(x, a, y): s = ((y - a.dot(x**2)) ** 2).sum() return s bounds = [[x, None] for x in x_lower_bounds] out = scipy.optimize.minimize( residual_ans, x0=x0, args=(a, y), method="L-BFGS-B", bounds=bounds ).x return out test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import scipy.optimize import numpy as np a, x_true, y, x0, x_lower_bounds = test_input [insert] result = out """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm trying to solve a simple ODE to visualise the temporal response, which works well for constant input conditions using the new solve_ivp integration API in SciPy. For example: def dN1_dt_simple(t, N1): return -100 * N1 sol = solve_ivp(fun=dN1_dt_simple, t_span=time_span, y0=[N0,]) However, I wonder is it possible to plot the response to a time-varying input? For instance, rather than having y0 fixed at N0, can I find the response to a simple sinusoid? Specifically, I want to change dy/dt = -100*y + sin(t) to let it become time-variant. The result I want is values of solution at time points. Is there a compatible way to pass time-varying input conditions into the API? A: <code> import scipy.integrate import numpy as np N0 = 10 time_span = [-0.1, 0.1] </code> solve this question with example variable `sol` and set `result = sol.y` BEGIN SOLUTION <code>

def dN1_dt (t, N1): return -100 * N1 + np.sin(t) sol = scipy.integrate.solve_ivp(fun=dN1_dt, t_span=time_span, y0=[N0,])

import numpy as np import copy import scipy.integrate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: N0 = 10 time_span = [-0.1, 0.1] return N0, time_span def generate_ans(data): _a = data N0, time_span = _a def dN1_dt(t, N1): return -100 * N1 + np.sin(t) sol = scipy.integrate.solve_ivp( fun=dN1_dt, t_span=time_span, y0=[ N0, ], ) return sol.y test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" import scipy.integrate import numpy as np N0, time_span = test_input [insert] result = sol.y """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I’m trying to solve a simple ODE to visualise the temporal response, which works well for constant input conditions using the new solve_ivp integration API in SciPy. For example: def dN1_dt_simple(t, N1): return -100 * N1 sol = solve_ivp(fun=dN1_dt_simple, t_span=[0, 100e-3], y0=[N0,]) However, I wonder is it possible to plot the response to a time-varying input? For instance, rather than having y0 fixed at N0, can I find the response to a simple sinusoid? Specifically, I want to add `t-sin(t) if 0 < t < 2pi else 2pi` to original y. The result I want is values of solution at time points. Is there a compatible way to pass time-varying input conditions into the API? A: <code> import scipy.integrate import numpy as np N0 = 1 time_span = [0, 10] </code> solve this question with example variable `sol` and set `result = sol.y` BEGIN SOLUTION <code>

def dN1_dt(t, N1): input = 1-np.cos(t) if 0<t<2*np.pi else 0 return -100*N1 + input sol = scipy.integrate.solve_ivp(fun=dN1_dt, t_span=time_span, y0=[N0,])

import numpy as np import copy import scipy.integrate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: N0 = 1 time_span = [0, 10] return N0, time_span def generate_ans(data): _a = data N0, time_span = _a def dN1_dt(t, N1): input = 1 - np.cos(t) if 0 < t < 2 * np.pi else 0 return -100 * N1 + input sol = scipy.integrate.solve_ivp( fun=dN1_dt, t_span=time_span, y0=[ N0, ], ) return sol.y test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" import scipy.integrate import numpy as np N0, time_span = test_input [insert] result = sol.y """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I’m trying to solve a simple ODE to visualise the temporal response, which works well for constant input conditions using the new solve_ivp integration API in SciPy. For example: def dN1_dt_simple(t, N1): return -100 * N1 sol = solve_ivp(fun=dN1_dt_simple, t_span=time_span, y0=[N0,]) However, I wonder is it possible to plot the response to a time-varying input? For instance, rather than having y0 fixed at N0, can I find the response to a simple sinusoid? Specifically, I want to add `-cos(t)` to original y. The result I want is values of solution at time points. Is there a compatible way to pass time-varying input conditions into the API? A: <code> import scipy.integrate import numpy as np N0 = 10 time_span = [-0.1, 0.1] </code> solve this question with example variable `sol` and set `result = sol.y` BEGIN SOLUTION <code>

def dN1_dt (t, N1): return -100 * N1 + np.sin(t) sol = scipy.integrate.solve_ivp(fun=dN1_dt, t_span=time_span, y0=[N0,])

import numpy as np import copy import scipy.integrate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: N0 = 10 time_span = [-0.1, 0.1] return N0, time_span def generate_ans(data): _a = data N0, time_span = _a def dN1_dt(t, N1): return -100 * N1 + np.sin(t) sol = scipy.integrate.solve_ivp( fun=dN1_dt, t_span=time_span, y0=[ N0, ], ) return sol.y test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): np.testing.assert_allclose(result, ans) return 1 exec_context = r""" import scipy.integrate import numpy as np N0, time_span = test_input [insert] result = sol.y """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I'm using scipy.optimize.minimize to solve a complex reservoir optimization model (SQSLP and COBYLA as the problem is constrained by both bounds and constraint equations). There is one decision variable per day (storage), and releases from the reservoir are calculated as a function of change in storage, within the objective function. Penalties based on releases and storage penalties are then applied with the goal of minimizing penalties (the objective function is a summation of all penalties). I've added some constraints within this model to limit the change in storage to the physical system limits which is the difference between decision variable x(t+1) and x(t), and also depends on inflows at that time step I(t). These constraints are added to the list of constraint dictionaries using a for loop. Constraints added outside of this for loop function as they should. However the constraints involving time that are initiated within the for loop, do not. Obviously the problem is complex so I've recreated a simpler version to illustrate the problem. This problem has four decision variables and seeks to minimize the objective function (which I've called function) with constraints of steady state (I = inflow must equal x = outflow) and non negativity (ie. outflows x cannot be negative): import numpy as np from scipy.optimize import minimize def function(x): return -1*(18*x[0]+16*x[1]+12*x[2]+11*x[3]) I=np.array((20,50,50,80)) x0=I cons=[] steadystate={'type':'eq', 'fun': lambda x: x.sum()-I.sum() } cons.append(steadystate) for t in range (4): def const(x): y=x[t] return y cons.append({'type':'ineq', 'fun': const}) out=minimize(function, x0, method="SLSQP", constraints=cons) x=out["x"] The constraints initiated in the for loop are non-negativity constraints but the optimization gives negative values for the decision variables. It does adhere to the steadystate constraint, however. Any ideas where I'm going wrong? I've seen constraints initiated similarly in other applications so I can't figure it out but assume it's something simple. I have hundreds of constraints to initiate in my full-scale version of this code so writing them out as in the second example will not be ideal. A: <code> import numpy as np from scipy.optimize import minimize def function(x): return -1*(18*x[0]+16*x[1]+12*x[2]+11*x[3]) I=np.array((20,50,50,80)) x0=I cons=[] steadystate={'type':'eq', 'fun': lambda x: x.sum()-I.sum() } cons.append(steadystate) </code> Carefully set `cons` for running the following code. BEGIN SOLUTION <code>

def f(a): def g(x): return x[a] return g for t in range (4): cons.append({'type':'ineq', 'fun': f(t)})

import numpy as np import copy from scipy.optimize import minimize def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: I = np.array((20, 50, 50, 80)) return I def generate_ans(data): _a = data def function(x): return -1 * (18 * x[0] + 16 * x[1] + 12 * x[2] + 11 * x[3]) I = _a x0 = I cons = [] steadystate = {"type": "eq", "fun": lambda x: x.sum() - I.sum()} cons.append(steadystate) def f(a): def g(x): return x[a] return g for t in range(4): cons.append({"type": "ineq", "fun": f(t)}) out = minimize(function, x0, method="SLSQP", constraints=cons) x = out["x"] return x test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import numpy as np from scipy.optimize import minimize def function(x): return -1*(18*x[0]+16*x[1]+12*x[2]+11*x[3]) I = test_input x0=I cons=[] steadystate={'type':'eq', 'fun': lambda x: x.sum()-I.sum() } cons.append(steadystate) [insert] out=minimize(function, x0, method="SLSQP", constraints=cons) x=out["x"] result = x """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I have problems using scipy.sparse.csr_matrix: for instance: a = csr_matrix([[1,2,3],[4,5,6]]) b = csr_matrix([[7,8,9],[10,11,12]]) how to merge them into [[1,2,3],[4,5,6],[7,8,9],[10,11,12]] I know a way is to transfer them into numpy array first: csr_matrix(numpy.vstack((a.toarray(),b.toarray()))) but it won't work when the matrix is huge and sparse, because the memory would run out. so are there any way to merge them together in csr_matrix? any answers are appreciated! A: <code> from scipy import sparse sa = sparse.random(10, 10, density = 0.01, format = 'csr') sb = sparse.random(10, 10, density = 0.01, format = 'csr') </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = sparse.vstack((sa, sb)).tocsr()

import copy import tokenize, io from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: sa = sparse.random(10, 10, density=0.01, format="csr", random_state=42) sb = sparse.random(10, 10, density=0.01, format="csr", random_state=45) return sa, sb def generate_ans(data): _a = data sa, sb = _a result = sparse.vstack((sa, sb)).tocsr() return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == sparse.csr.csr_matrix assert len(sparse.find(result != ans)[0]) == 0 return 1 exec_context = r""" from scipy import sparse sa, sb = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert ( "toarray" not in tokens and "array" not in tokens and "todense" not in tokens and "A" not in tokens )

Problem: I have problems using scipy.sparse.csr_matrix: for instance: a = csr_matrix([[1,2,3],[4,5,6]]) b = csr_matrix([[7,8,9],[10,11,12]]) how to merge them into [[1,2,3,7,8,9],[4,5,6,10,11,12]] I know a way is to transfer them into numpy array first: csr_matrix(numpy.hstack((a.toarray(),b.toarray()))) but it won't work when the matrix is huge and sparse, because the memory would run out. so are there any way to merge them together in csr_matrix? any answers are appreciated! A: <code> from scipy import sparse sa = sparse.random(10, 10, density = 0.01, format = 'csr') sb = sparse.random(10, 10, density = 0.01, format = 'csr') </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = sparse.hstack((sa, sb)).tocsr()

import copy import tokenize, io from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: sa = sparse.random(10, 10, density=0.01, format="csr", random_state=42) sb = sparse.random(10, 10, density=0.01, format="csr", random_state=45) return sa, sb def generate_ans(data): _a = data sa, sb = _a result = sparse.hstack((sa, sb)).tocsr() return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == sparse.csr.csr_matrix assert len(sparse.find(result != ans)[0]) == 0 return 1 exec_context = r""" from scipy import sparse sa, sb = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result) def test_string(solution: str): tokens = [] for token in tokenize.tokenize(io.BytesIO(solution.encode("utf-8")).readline): tokens.append(token.string) assert ( "toarray" not in tokens and "array" not in tokens and "todense" not in tokens and "A" not in tokens )

Problem: I would like to write a program that solves the definite integral below in a loop which considers a different value of the constant c per iteration. I would then like each solution to the integral to be outputted into a new array. How do I best write this program in python? ∫2cxdx with limits between 0 and 1. from scipy import integrate integrate.quad Is acceptable here. My major struggle is structuring the program. Here is an old attempt (that failed) # import c fn = 'cooltemp.dat' c = loadtxt(fn,unpack=True,usecols=[1]) I=[] for n in range(len(c)): # equation eqn = 2*x*c[n] # integrate result,error = integrate.quad(lambda x: eqn,0,1) I.append(result) I = array(I) A: <code> import scipy.integrate c = 5 low = 0 high = 1 </code> result = ... # put solution in this variable BEGIN SOLUTION <code>

result = scipy.integrate.quadrature(lambda x: 2*c*x, low, high)[0]

import numpy as np import copy import scipy.integrate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: c = 5 low = 0 high = 1 return c, low, high def generate_ans(data): _a = data c, low, high = _a result = scipy.integrate.quadrature(lambda x: 2 * c * x, low, high)[0] return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import scipy.integrate c, low, high = test_input [insert] """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: I would like to write a program that solves the definite integral below in a loop which considers a different value of the constant c per iteration. I would then like each solution to the integral to be outputted into a new array. How do I best write this program in python? ∫2cxdx with limits between 0 and 1. from scipy import integrate integrate.quad Is acceptable here. My major struggle is structuring the program. Here is an old attempt (that failed) # import c fn = 'cooltemp.dat' c = loadtxt(fn,unpack=True,usecols=[1]) I=[] for n in range(len(c)): # equation eqn = 2*x*c[n] # integrate result,error = integrate.quad(lambda x: eqn,0,1) I.append(result) I = array(I) A: <code> import scipy.integrate def f(c=5, low=0, high=1): # return the solution in this function # result = f(c=5, low=0, high=1) ### BEGIN SOLUTION

result = scipy.integrate.quadrature(lambda x: 2*c*x, low, high)[0] return result

import numpy as np import copy import scipy.integrate def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: c = 5 low = 0 high = 1 return c, low, high def generate_ans(data): _a = data c, low, high = _a result = scipy.integrate.quadrature(lambda x: 2 * c * x, low, high)[0] return result test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert np.allclose(result, ans) return 1 exec_context = r""" import scipy.integrate c, low, high = test_input def f(c=5, low=0, high=1): [insert] result = f(c, low, high) """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: First off, I'm no mathmatician. I admit that. Yet I still need to understand how ScyPy's sparse matrices work arithmetically in order to switch from a dense NumPy matrix to a SciPy sparse matrix in an application I have to work on. The issue is memory usage. A large dense matrix will consume tons of memory. The formula portion at issue is where a matrix is added to a scalar. A = V + x Where V is a square sparse matrix (its large, say 60,000 x 60,000). x is a float. What I want is that x will only be added to non-zero values in V. With a SciPy, not all sparse matrices support the same features, like scalar addition. dok_matrix (Dictionary of Keys) supports scalar addition, but it looks like (in practice) that it's allocating each matrix entry, effectively rendering my sparse dok_matrix as a dense matrix with more overhead. (not good) The other matrix types (CSR, CSC, LIL) don't support scalar addition. I could try constructing a full matrix with the scalar value x, then adding that to V. I would have no problems with matrix types as they all seem to support matrix addition. However I would have to eat up a lot of memory to construct x as a matrix, and the result of the addition could end up being fully populated matrix as well. There must be an alternative way to do this that doesn't require allocating 100% of a sparse matrix. I’d like to solve the problem on dok matrix first. I'm will to accept that large amounts of memory are needed, but I thought I would seek some advice first. Thanks. A: <code> import numpy as np from scipy import sparse V = sparse.random(10, 10, density = 0.05, format = 'dok', random_state = 42) x = 99 </code> V = ... # put solution in this variable BEGIN SOLUTION <code>

V._update(zip(V.keys(), np.array(list(V.values())) + x))

import numpy as np import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: V = sparse.random(10, 10, density=0.05, format="dok", random_state=42) x = 99 elif test_case_id == 2: V = sparse.random(15, 15, density=0.05, format="dok", random_state=42) x = 5 return V, x def generate_ans(data): _a = data V, x = _a V._update(zip(V.keys(), np.array(list(V.values())) + x)) return V test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert len(sparse.find(ans != result)[0]) == 0 return 1 exec_context = r""" import numpy as np from scipy import sparse V, x = test_input [insert] result = V """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: First off, I'm no mathmatician. I admit that. Yet I still need to understand how ScyPy's sparse matrices work arithmetically in order to switch from a dense NumPy matrix to a SciPy sparse matrix in an application I have to work on. The issue is memory usage. A large dense matrix will consume tons of memory. The formula portion at issue is where a matrix is added to a scalar. A = V + x Where V is a square sparse matrix (its large, say 60,000 x 60,000). x is a float. What I want is that x will only be added to non-zero values in V. With a SciPy, not all sparse matrices support the same features, like scalar addition. dok_matrix (Dictionary of Keys) supports scalar addition, but it looks like (in practice) that it's allocating each matrix entry, effectively rendering my sparse dok_matrix as a dense matrix with more overhead. (not good) The other matrix types (CSR, CSC, LIL) don't support scalar addition. I could try constructing a full matrix with the scalar value x, then adding that to V. I would have no problems with matrix types as they all seem to support matrix addition. However I would have to eat up a lot of memory to construct x as a matrix, and the result of the addition could end up being fully populated matrix as well. There must be an alternative way to do this that doesn't require allocating 100% of a sparse matrix. I’d like to solve the problem on coo matrix first. I'm will to accept that large amounts of memory are needed, but I thought I would seek some advice first. Thanks. A: <code> from scipy import sparse V = sparse.random(10, 10, density = 0.05, format = 'coo', random_state = 42) x = 100 </code> V = ... # put solution in this variable BEGIN SOLUTION <code>

V.data += x

import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: V = sparse.random(10, 10, density=0.05, format="coo", random_state=42) x = 100 elif test_case_id == 2: V = sparse.random(15, 15, density=0.05, format="coo", random_state=42) x = 5 return V, x def generate_ans(data): _a = data V, x = _a V.data += x return V test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert len(sparse.find(ans != result)[0]) == 0 return 1 exec_context = r""" from scipy import sparse V, x = test_input [insert] result = V """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: First off, I'm no mathmatician. I admit that. Yet I still need to understand how ScyPy's sparse matrices work arithmetically in order to switch from a dense NumPy matrix to a SciPy sparse matrix in an application I have to work on. The issue is memory usage. A large dense matrix will consume tons of memory. The formula portion at issue is where a matrix is added to some scalars. A = V + x B = A + y Where V is a square sparse matrix (its large, say 60,000 x 60,000). What I want is that x, y will only be added to non-zero values in V. With a SciPy, not all sparse matrices support the same features, like scalar addition. dok_matrix (Dictionary of Keys) supports scalar addition, but it looks like (in practice) that it's allocating each matrix entry, effectively rendering my sparse dok_matrix as a dense matrix with more overhead. (not good) The other matrix types (CSR, CSC, LIL) don't support scalar addition. I could try constructing a full matrix with the scalar value x, then adding that to V. I would have no problems with matrix types as they all seem to support matrix addition. However I would have to eat up a lot of memory to construct x as a matrix, and the result of the addition could end up being fully populated matrix as well. There must be an alternative way to do this that doesn't require allocating 100% of a sparse matrix. I’d like to solve the problem on coo matrix first. I'm will to accept that large amounts of memory are needed, but I thought I would seek some advice first. Thanks. A: <code> from scipy import sparse V = sparse.random(10, 10, density = 0.05, format = 'coo', random_state = 42) x = 100 y = 99 </code> V = ... # put solution in this variable BEGIN SOLUTION <code>

V = V.copy() V.data += x V.eliminate_zeros() V.data += y V.eliminate_zeros()

import numpy as np import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: V = sparse.random(10, 10, density=0.05, format="coo", random_state=42) x = 100 y = 99 elif test_case_id == 2: V = sparse.coo_matrix(np.diag(-np.arange(5))) x = 1 y = 1 return V, x, y def generate_ans(data): _a = data V, x, y = _a V = V.copy() V.data += x V.eliminate_zeros() V.data += y V.eliminate_zeros() return V test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert len(sparse.find(ans != result)[0]) == 0 return 1 exec_context = r""" from scipy import sparse V, x, y = test_input [insert] result = V """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(2): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)

Problem: Basically, I am just trying to do a simple matrix multiplication, specifically, extract each column of it and normalize it by dividing it with its length. #csc sparse matrix self.__WeightMatrix__ = self.__WeightMatrix__.tocsc() #iterate through columns for Col in xrange(self.__WeightMatrix__.shape[1]): Column = self.__WeightMatrix__[:,Col].data List = [x**2 for x in Column] #get the column length Len = math.sqrt(sum(List)) #here I assumed dot(number,Column) would do a basic scalar product dot((1/Len),Column) #now what? how do I update the original column of the matrix, everything that have been returned are copies, which drove me nuts and missed pointers so much I've searched through the scipy sparse matrix documentations and got no useful information. I was hoping for a function to return a pointer/reference to the matrix so that I can directly modify its value. Thanks A: <code> from scipy import sparse import numpy as np import math sa = sparse.random(10, 10, density = 0.3, format = 'csc', random_state = 42) </code> sa = ... # put solution in this variable BEGIN SOLUTION <code>

sa = sparse.csc_matrix(sa.toarray() / np.sqrt(np.sum(sa.toarray()**2, axis=0)))

import numpy as np import copy from scipy import sparse def generate_test_case(test_case_id): def define_test_input(test_case_id): if test_case_id == 1: sa = sparse.random(10, 10, density=0.3, format="csc", random_state=42) return sa def generate_ans(data): _a = data sa = _a sa = sparse.csc_matrix( sa.toarray() / np.sqrt(np.sum(sa.toarray() ** 2, axis=0)) ) return sa test_input = define_test_input(test_case_id) expected_result = generate_ans(copy.deepcopy(test_input)) return test_input, expected_result def exec_test(result, ans): assert type(result) == sparse.csc.csc_matrix assert len(sparse.find(result != ans)[0]) == 0 return 1 exec_context = r""" from scipy import sparse import numpy as np import math sa = test_input [insert] result = sa """ def test_execution(solution: str): code = exec_context.replace("[insert]", solution) for i in range(1): test_input, expected_result = generate_test_case(i + 1) test_env = {"test_input": test_input} exec(code, test_env) assert exec_test(test_env["result"], expected_result)