\\n\\n

How does the survival rate of the passengers differ between sexes?<\\/li>\\n<\\/ul> \\n\\n<\\/div>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndf.groupby('Sex')[['Survived']].mean()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"4. Is there a relationship between the amount of rain and water quality? Show this relationship graphically. If you can, estimate the effect of rain on quality at different sites and create a visualization to compare them\\n\",\"targets\":\"relationship = data[['EnteroCount','FourDayRainTotal']]\\nrelationship.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Change if you have memory restrictions\\nbatch_size = 128\\n\\n# TODO: Find the best parameters for each configuration\\nepochs = 5\\nlearning_rate = 0.02\\n\\n\\n\\n### DON'T MODIFY ANYTHING BELOW ###\\n# Gradient Descent\\noptimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss) \\n\\n# The accuracy measured against the validation set\\nvalidation_accuracy = 0.0\\n\\n# Measurements use for graphing loss and accuracy\\nlog_batch_step = 50\\nbatches = []\\nloss_batch = []\\ntrain_acc_batch = []\\nvalid_acc_batch = []\\n\\nwith tf.Session() as session:\\n session.run(init)\\n batch_count = int(math.ceil(len(train_features)\\/batch_size))\\n\\n for epoch_i in range(epochs):\\n \\n # Progress bar\\n batches_pbar = tqdm(range(batch_count), desc='Epoch {:>2}\\/{}'.format(epoch_i+1, epochs), unit='batches')\\n \\n # The training cycle\\n for batch_i in batches_pbar:\\n # Get a batch of training features and labels\\n batch_start = batch_i*batch_size\\n batch_features = train_features[batch_start:batch_start + batch_size]\\n batch_labels = train_labels[batch_start:batch_start + batch_size]\\n\\n # Run optimizer and get loss\\n _, l = session.run(\\n [optimizer, loss],\\n feed_dict={features: batch_features, labels: batch_labels})\\n\\n # Log every 50 batches\\n if not batch_i % log_batch_step:\\n # Calculate Training and Validation accuracy\\n training_accuracy = session.run(accuracy, feed_dict=train_feed_dict)\\n validation_accuracy = session.run(accuracy, feed_dict=valid_feed_dict)\\n\\n # Log batches\\n previous_batch = batches[-1] if batches else 0\\n batches.append(log_batch_step + previous_batch)\\n loss_batch.append(l)\\n train_acc_batch.append(training_accuracy)\\n valid_acc_batch.append(validation_accuracy)\\n\\n # Check accuracy against Validation data\\n validation_accuracy =...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n\\nProblem 3\\nBelow are 2 parameter configurations for training the neural network. In each configuration, one of the parameters has multiple options. For each configuration, choose the option that gives the best acccuracy.\\nParameter configurations:\\nConfiguration 1\\n* Epochs: 1\\n* Learning Rate:\\n * 0.8\\n * 0.5\\n * 0.1\\n * 0.05\\n * 0.01\\nConfiguration 2\\n* Epochs:\\n * 1\\n * 2\\n * 3\\n * 4\\n * 5\\n* Learning Rate: 0.2\\nThe code will print out a Loss and Accuracy graph, so you can see how well the neural network performed.\\nIf you're having trouble solving problem 3, you can view the solution here.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Set the current working directory, so that all files created will be stored there.\\n# The best bet is to create a folder named 'temp' on your desktop.\\nos.chdir('path')\\n\\n# Insert the path to the write-good folder on your machine.\\nmylogs = gn.get_log('path')\\n# You can generate a network using any two tags that exist in the log. For a list of tags, just call .attributes() on your log object.\\ngraph = mylogs.generate_network('author', 'files')\\n# Quickplot is a preset function that can be used to quickly visualize a network.\\ngraph.quickplot('write_good_net.pdf', layout = 'spring')\\n\\n# You can get a list of all of the values of any tag in the log object.\\n# First, lets take a look at all of the possible tags.\\nprint(mylogs.attributes())\\n# Now, lets print that list of values. Choose one of the tags from above.\\nprint(mylogs.vector('date'))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n1. Write-Good Repo\\nFor this exercise, we are going to use the project: https:\\/\\/github.com\\/btford\\/write-good\\nIn a new terminal window, type:\\ngit clone https:\\/\\/github.com\\/btford\\/write-good.git\\nOR open the page in a browser and download the zip folder.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"4.2 Query runs\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncursor.execute(\\\"SELECT * FROM runs where experiment_id={} ORDER BY start_time desc LIMIT 1\\\".format(experiment_id))\\nif cursor.rowcount == 0:\\n print(\\\"No runs found\\\")\\nelse:\\n entity=list(cursor)[0]\\n run_uuid = entity[0]\\n print(f\\\"Last run id of '{experiment_name}' experiment is: {run_uuid}\\\\n\\\")\\n print(entity)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Notebooks\\/Numpy+Scipy\\/1 - Introduction to Numpy.ipynb\\\".\\nThe first task is:\\nExercise: look through the functions below from numpy, choose 3 of them and work out how to use them on arrays of data. Write a few lines to explain what you find. \\n\\nnp.max v. np.argmax\\nnp.where\\nnp.logical_and\\nnp.fill_diagonal\\nnp.count_nonzero\\nnp.isinf and np.isnan\\n\\nHere is an example: \\nnp.concatenate takes a number of arrays and glues them together. For 1D arrays this is simple:\\n```python\\nA = np.array([1.0,1.0,1.0,1.0])\\nB = np.array([2.0,2.0,2.0,2.0])\\nC = np.array([3.0,3.0,3.0,3.0])\\nR = np.concatenate((A,B,C))\\narray([ 1., 1., 1., 1., 2., 2., 2., 2., 3., 3., 3., 3.])\\n```\\nan equivalent statement is np.hstack((A,B,C)) but note the difference with np.vstack((A,B,C))\\nWith higher dimensional arrays, the gluing takes place along one axis:\\n```python\\nA = np.array(([1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0]))\\nB = np.array(([3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0]))\\nC = np.array(([5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0]))\\nR = np.concatenate((A,B,C))\\nprint R\\nprint\\nR = np.concatenate((A,B,C), axis=1)\\nprint R\\n```\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Test the results here \\n\\nA = np.array(([1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0]))\\nB = np.array(([3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0]))\\nC = np.array(([5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0]))\\n\\nR = np.concatenate((A,B,C))\\nprint R\\nprint\\nR = np.concatenate((A,B,C), axis=1)\\nprint R\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Jupyter\\/LoadDataMimic-II.ipynb\\\".\\nThe first task is:\\nSciPy (optional)\\ntested with versions 0.10-0.12. (0.19.0) Required only for importing\\/exporting SciDB arrays as SciPy sparse matrices.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport scipy\\nscipy.__version__\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Notebooks\\/2016_05_23_Epi2_pilot_datasets_analysis_PTM.ipynb\\\".\\nThe first task is:\\nI reformated and filtered the database with reformat_table to be BED6 compatible. I removed the fields lacking either chromosome, position, tissue, and PID as well as with unknown strand. In addition I also selected only A>I and A>G transitions (same thing). This filtering step eliminated 47965 sites\\nCan you write Python code for it?\\n\",\"targets\":\"\\nd={}\\n\\nwith open(\\\".\\/PTM_Original_Datasets\\/DARNED_human_hg19_inosine.bed\\\", \\\"r\\\") as f:\\n for line in f:\\n if line [0] !=\\\"#\\\":\\n ls = supersplit(line, [\\\"\\\\t\\\",\\\"|\\\"])\\n n_tissue = len(ls[4].split(\\\",\\\"))\\n n_PMID = len(ls[6].split(\\\",\\\"))\\n key=\\\"{}:{}\\\".format(n_tissue,n_PMID)\\n if key not in d:\\n d[key]=0\\n d[key]+=1\\n\\nprint (d)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Como podemos observar na tabela acima, os novos atributos que criamos agora estão alinhados com o status do atleta e poderão nos ajudar na etapa da modelagem. Antes de modelar, vamos explorar ainda nossos dados.\\nPrimeira, observação para entendermos o modelo. O jogador quando está suspenso (linha 21137) ou seu status é nulo, não houve variação de preço. Há também outro ponto a ser observado, caso a pontuação do atleta seja positiva, há uma tendência de valorização. Vamos analisar isso nos dois gráficos abaixo.\\n\",\"targets\":\"# Transformar dados para plotar resultados\\npaqueta_plot = pd.melt(paqueta, \\n id_vars=['slug','rodada'], \\n value_vars=['variacao_preco_lag', 'pontos_lag', 'preco'])\\n\\n# Plotar gráfico com variacao_preco_lag, pontos_lag e preco\\nplt.figure(figsize=(16, 6))\\ng = sns.lineplot(x='rodada', y='value', hue='variable', data=paqueta_plot)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"(3c) Gradient descent \\nNext, implement a gradient descent function for linear regression and test out this function on an example.\\n\",\"targets\":\"def linregGradientDescent(trainData, numIters):\\n \\\"\\\"\\\"Calculates the weights and error for a linear regression model trained with gradient descent.\\n\\n Note:\\n `DenseVector` behaves similarly to a `numpy.ndarray` and they can be used interchangably\\n within this function. For example, they both implement the `dot` method.\\n\\n Args:\\n trainData (RDD of LabeledPoint): The labeled data for use in training the model.\\n numIters (int): The number of iterations of gradient descent to perform.\\n\\n Returns:\\n (np.ndarray, np.ndarray): A tuple of (weights, training errors). Weights will be the\\n final weights (one weight per feature) for the model, and training errors will contain\\n an error (RMSE) for each iteration of the algorithm.\\n \\\"\\\"\\\"\\n # The length of the training data\\n n = trainData.count()\\n \\n # The number of features in the training data\\n d = len(trainData.take(1)[0].features)\\n w = np.zeros(d)\\n alpha = 1.0\\n \\n # We will compute and store the training error after each iteration\\n errorTrain = np.zeros(numIters)\\n for i in range(numIters):\\n # Use getLabeledPrediction from (3b) with trainData to obtain an RDD of (label, prediction)\\n # tuples. Note that the weights all equal 0 for the first iteration, so the predictions will\\n # have large errors to start.\\n \\n labelsAndPredsTrain = trainData.map(lambda r: getLabeledPrediction(w, r))\\n errorTrain[i] = calcRMSE(labelsAndPredsTrain)\\n\\n # Calculate the `gradient`. Make use of the `gradientSummand` function you wrote in (3a).\\n # Note that `gradient` sould be a `DenseVector` of length `d`.\\n gradient = trainData.map(lambda r: gradientSummand(w, r)).sum()\\n \\n # Update the weights\\n alpha_i = alpha \\/ (n * np.sqrt(i+1))\\n w -= gradient * alpha_i\\n\\n return w, errorTrain\\n\\n# Create a toy dataset with n = 10, d = 3, and then run 5 iterations of gradient descent\\n# note: the resulting model will not be...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Crud, doing a harvest yields results where only 33% of our sample is worth examining further. \\nData Exploration\\nLet's get the top 10 headlines grouped by img\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndeduped['headline'].groupby(deduped['img']).value_counts().nlargest(10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"PmagPy_calculations.ipynb\\\".\\nThe first task is:\\nsquish\\n[Essentials Chapter 7] [command line version]\\nThis program reads in dec\\/inc data and \\\"squishes\\\" the inclinations using the formula from King \\n(1955, doi: 10.1111\\/j.1365-246X.1955.tb06558.x) $\\\\tan(I_o)=flat \\\\tan(I_f)$. [See also unsquish]. \\nWe can call pmag.squish() from within the notebook.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nhelp(pmag.squish)\\n\\ndi_block=np.loadtxt('data_files\\/squish\\/squish_example.dat').transpose()\\ndecs=di_block[0]\\nincs=di_block[1]\\nflat=0.4\\nfincs=pmag.squish(incs,flat)\\n\\nipmag.plot_net(1)\\nipmag.plot_di(dec=decs,inc=incs,title='Original',color='blue')\\nipmag.plot_net(2)\\nipmag.plot_di(dec=decs,inc=fincs,title='Squished',color='red')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Compute the RSS on the TEST data for the following three sets of weights:\\n1. The initial weights (all zeros)\\n2. The weights learned with no regularization\\n3. The weights learned with high regularization\\nWhich weights perform best?\\n\",\"targets\":\"initial_predictions = predict_output(simple_test_feature_matrix, initial_weights)\\ninitial_residuals = test_output - initial_predictions\\ninitial_RSS = (initial_residuals **2).sum()\\nprint initial_RSS\\n\\nno_regularization_predictions = predict_output(simple_test_feature_matrix, simple_weights_0_penalty)\\nno_regularization_residuals = test_output - no_regularization_predictions\\nno_regularization_RSS = (no_regularization_residuals **2).sum()\\nprint no_regularization_RSS\\n\\nregularization_predictions = predict_output(simple_test_feature_matrix, simple_weights_high_penalty)\\nregularization_residuals = test_output - regularization_predictions\\nregularization_RSS = (regularization_residuals **2).sum()\\nprint regularization_RSS\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Contents\\nGenerate Fibonacci numbers\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef generate_fibonacci_list(limit, output=False):\\n nums = []\\n current, ne_xt = 0, 1\\n\\n while current < limit:\\n current, ne_xt = ne_xt, ne_xt + current\\n nums.append(current)\\n\\n if output == True:\\n print(f'{len(nums[:-1])} Fibonacci numbers below the number '\\n f'{limit} are:\\\\n{nums[:-1]}')\\n\\n return nums[:-1]\\n\\n\\nlimit = 1000\\nfib = generate_fibonacci_list(limit, True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"5. Print the names of all coordinates on the cube. (Hint: Remember the cube.coords method)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfor coord in cube.coords():\\n print(coord.name())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Author a pipeline with the above components\\n\",\"targets\":\"from kfp.deprecated import components as comp\\nfrom kfp.deprecated import dsl\\nfrom kfp.deprecated import compiler\\n\\n# The components are loaded as task factories that generate container_ops.\\ntask_factory_a = comp.load_component_from_text(text=component_a)\\ntask_factory_b = comp.load_component_from_text(text=component_b)\\n\\n#Use the component as part of the pipeline\\n@dsl.pipeline(name='type-check-a',\\n description='')\\ndef pipeline_a():\\n a = task_factory_a(field_l=12)\\n b = task_factory_b(field_x=a.outputs['field_n'], field_y=a.outputs['field_o'], field_z=a.outputs['field_m'])\\n\\ncompiler.Compiler().compile(pipeline_a, 'pipeline_a.zip', type_check=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Split into a training set (75%) and a test set (25%) \\n\\nX_train, X_test, y_train, y_test = train_test_split(\\n X, y, test_size=0.25, random_state=42)\\n\\nmean_image = np.mean(X_train,axis=0)\\nplt.figure\\nplt.imshow(mean_image.reshape((64,64)), cmap=plt.cm.gray)\\nplt.xticks(())\\nplt.yticks(())\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nShuffle the data randomly and make train and test splits\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# If the metricValue is 1, the object was detected\\nnum = np.where(bundle.metricValues == 1)[0].size\\nprint 'Number of detections = %i' % num\\n\\n# If the value was zero, and unmasked, that means some observations \\n# were taken at that point in the sky\\nnum = np.where((bundle.metricValues == 0) & (bundle.metricValues.mask == False))[0].size\\nprint 'Number of non-detections = %i' % num\\n\\n# Find the number of transients where LSST took no observations at that spot\\nnum = np.where( (bundle.metricValues == 0) &\\n (bundle.metricValues.mask == True))[0].size\\nprint 'Number of transients with no overlapping observations at that spot = %i' % num\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNote a possibly confusing fature in the plots here: The histogram shows ~600 transients were not detected, and ~50 were. But we input 1,000. The sky map also has no points in the far north. This is a \\\"feature\\\" of MAF that if a point in the sky has no overlapping observations, that point is masked. Only unmasked points get plotted by default. We can check this explicitly by inspecting the metricValues.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Calibration\\nSeveral types of calibrations are supported. The simplest calibration assumes that frequency response is \\\"flat\\\". In other words, if you send a 1V RMS tone to the speaker, it will always produce the same output level regardless of frequency. You can also have calibrations that compensate for variations in speaker output as a function of frequency.\\nFor simplicity, let's assume our speaker's response is flat. First, import the calibration class that supports flat calibrations.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom psi.controller.calibration.api import FlatCalibration\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Additionally, energy interval over which to average, can be specified by specifying e0 and e1 parameters.\\nObtaining Energy-Resolved Response\\nEnergy-resolved\\/time-averaged response can be also be formed from 2-d transfer function.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntransfer.energy_response()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\n\\n\",\"targets\":\"print('for T = ', temp)\\nfor eta_i, p_i in zip(eta, p):\\n print(\\\"{0: .3f} {1: .2f}\\\".format(eta_i, p_i))\\n\\nv = jamieson_mgo.cal_v(p, temp * np.ones_like(p))\\nprint(1.-(v\\/v0))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Equalize\\\": Make rhythms the same length\\nUse LCM to \\\"equalize\\\" rhythms so that they're of equal length.\\ne.g.\\na = [1,0,0,1]\\nb = [1,1,0]\\nbecome\\nequalized_a = [1,-,-,0,-,-,0,-,-,1,-,-]\\nequalized_b = [1,-,-,-,1,-,-,-,0,-,-,-]\\n\",\"targets\":\"# \\\"Equalize\\\" (i.e. scale rhythms so they're of equal length)\\ndef equalize_rhythm_subdivisions(original_rhythm, target_rhythm, delimiter=\\\"-\\\"):\\n original_length = len(original_rhythm)\\n target_length = len(target_rhythm)\\n lcm = (original_length*target_length) \\/ fibonaccistretch.euclid(original_length, target_length)\\n original_scale_factor = (lcm \\/ original_length) - 1\\n target_scale_factor = (lcm \\/ target_length) - 1\\n \\n print(\\\"lcm={}, original_scale_factor={}, target_scale_factor={}\\\").format(lcm, original_scale_factor, target_scale_factor)\\n \\n delimiter = str(delimiter)\\n original_rhythm = list((delimiter*original_scale_factor).join([str(x) for x in original_rhythm]))\\n target_rhythm = list((delimiter*target_scale_factor).join([str(x) for x in target_rhythm]))\\n \\n original_rhythm.extend(list(delimiter*original_scale_factor))\\n target_rhythm.extend(list(delimiter*target_scale_factor))\\n\\n \\n return (original_rhythm, target_rhythm)\\n\\n# print(scale_rhythm_subdivisions(original_rhythm, target_rhythm))\\noriginal_rhythm, target_rhythm = generate_original_and_target_rhythms(3, 8, 13)\\nprint(\\\"Original rhythm: {} Target rhythm: {}\\\".format(original_rhythm, target_rhythm))\\nequalized_original_rhythm, equalized_target_rhythm = equalize_rhythm_subdivisions(original_rhythm, target_rhythm)\\n(len(equalized_original_rhythm), len(equalized_target_rhythm))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"NEU\\/Sai_Raghuram_Kothapalli_DL\\/Hands_on_Keras_Tutorial.ipynb\\\".\\nThe first task is:\\nCompilation\\nBefore training a model, you need to configure the learning process, which is done via the compile method. It receives three arguments:\\n\\nAn optimizer. This could be the string identifier of an existing optimizer (such as rmsprop or adagrad), or an instance of the Optimizer class. See: optimizers.\\nA loss function. This is the objective that the model will try to minimize. It can be the string identifier of an existing loss function (such as categorical_crossentropy or mse), or it can be an objective function. See: losses.\\nA list of metrics. For any classification problem you will want to set this to metrics=['accuracy']. A metric could be the string identifier of an existing metric or a custom metric function.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# For a multi-class classification problem\\nmodel.compile(optimizer='rmsprop',\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n\\n# For a binary classification problem\\nmodel.compile(optimizer='rmsprop',\\n loss='binary_crossentropy',\\n metrics=['accuracy'])\\n\\n# For a mean squared error regression problem\\nmodel.compile(optimizer='rmsprop',\\n loss='mse')\\n\\n# For custom metrics\\nimport keras.backend as K\\n\\ndef mean_pred(y_true, y_pred):\\n return K.mean(y_pred)\\n\\nmodel.compile(optimizer='rmsprop',\\n loss='binary_crossentropy',\\n metrics=['accuracy', mean_pred])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Analyse data :\\nPetits rappels\\nPour lire un fichier .csv on utilise la fonction de read_csv de la librairie Pandas. Si vous voulez connaitre l'ensemble de paramètres de la fonction : read_csv? (une fenêtre d'aide s'ouvrira).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Charger la lib\\nimport pandas as pd\\n\\n#Afficher l'aide\\n#pd.read_csv?\\n\\ndata = pd.read_csv('data\\/train.csv') # Chargement des données.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"<\\/a>\\nMean function\\nThe mean function of a stochastic process $X(t)$ is a deterministic function which maps $t$ to $E(X(t))$. The mean function can be estimated and plotted by simulating many sample paths of the process and using .mean().\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npaths = X.sim(1000)\\nplot(paths)\\nplot(paths.mean(), 'r')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"ML_lab3_linear_reg_student.ipynb\\\".\\nThe first task is:\\n(1d) Shift labels \\nAs we just saw, the labels are years in the 1900s and 2000s. In learning problems, it is often natural to shift labels such that they start from zero. Starting with parsedDataInit, create a new RDD consisting of LabeledPoint objects in which the labels are shifted such that smallest label equals zero.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# TODO: Replace with appropriate code\\nparsedData = parsedDataInit.map(lambda x: LabeledPoint(x.label - minYear, x.features))\\n\\n# Should be a LabeledPoint\\nprint type(parsedData.take(1)[0])\\n# View the first point\\nprint '\\\\n{0}'.format(parsedData.take(1))\\n\\n# TEST Shift labels (1d)\\noldSampleFeatures = parsedDataInit.take(1)[0].features\\nnewSampleFeatures = parsedData.take(1)[0].features\\nTest.assertTrue(np.allclose(oldSampleFeatures, newSampleFeatures),\\n 'new features do not match old features')\\nsumFeatTwo = parsedData.map(lambda lp: lp.features[2]).sum()\\nTest.assertTrue(np.allclose(sumFeatTwo, 3158.96224351), 'parsedData has unexpected values')\\nminYearNew = parsedData.map(lambda lp: lp.label).min()\\nmaxYearNew = parsedData.map(lambda lp: lp.label).max()\\nTest.assertTrue(minYearNew == 0, 'incorrect min year in shifted data')\\nTest.assertTrue(maxYearNew == 89, 'incorrect max year in shifted data')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"As you can see, this makes the code much shorter and easier to handle. Behind the scenes, exactly the same as above is happening. When calling fit on the pipeline, it will call fit on each step in turn.\\nAfter the first step is fit, it will use the transform method of the first step to create a new representation.\\nThis will then be fed to the fit of the next step, and so on.\\nFinally, on the last step, only fit is called.\\n\\nIf we call score, only transform will be called on each step - this could be the test set after all! Then, on the last step, score is called with the new representation. The same goes for predict.\\nBuilding pipelines not only simplifies the code, it is also important for model selection.\\nSay we want to grid-search C to tune our Logistic Regression above.\\nLet's say we do it like this:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# This illustrates a common mistake. Don't use this code!\\nfrom sklearn.model_selection import GridSearchCV\\n\\nvectorizer = TfidfVectorizer()\\nvectorizer.fit(text_train)\\n\\nX_train = vectorizer.transform(text_train)\\nX_test = vectorizer.transform(text_test)\\n\\nclf = LogisticRegression()\\ngrid = GridSearchCV(clf, param_grid={'C': [.1, 1, 10, 100]}, cv=5)\\ngrid.fit(X_train, y_train)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"10．对上题所示电力系统，试作以标幺值表示的阻抗图。并将参数注在图上。取基准功率$S_{B}=100MVA$ ；$110KV$级的基准电压$U_{B}=110kV$ 。\\n有两种做法，一种将各实际值归算到110kv等级然后除以110kv的基值。另一种，将110kv基值归算到各电压等级，得到各电压等级的基值。\\n因为110的值已经算出很容易得出结论，因此在此我先采取第一种做法.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n#标幺值计算1\\nUB=110#kv\\nSB=100#MVA\\nXB=UB**2\\/SB\\npuv=lambda x,xb:x\\/xb\\nX_L2b=puv(X_L2x,XB)\\nX_L1b=puv(X_L1x,XB)\\nX_T1b=puv(X_T1x,XB)\\nX_T2b=puv(X_T2x,XB)\\n\\nprint(\\\"X_L2=%.3f\\\"%X_L2b)\\nprint(\\\"X_L1=%.3f\\\"%X_L1b)\\nprint(\\\"X_T1=%.3f\\\"%X_T1b)\\nprint(\\\"X_T2=%.3f\\\"%X_T2b)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"
\\n אם ננסה לעשות unpacking לאיבר שאינו iterable, תתקבל השגיאה הבאה:\\n<\\/p>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\na, b = 5\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Although there's no obvious relationship in this case, such analyses may be\\nuseful for metadata variables that more directly index the time course of\\nstimulus processing (such as reaction time).\\nAdding metadata to an Epochs object\\nYou can add a metadata :class:~pandas.DataFrame to any\\n~mne.Epochs object (or replace existing metadata) simply by\\nassigning to the :attr:~mne.Epochs.metadata attribute:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnew_metadata = pd.DataFrame(data=['foo'] * len(epochs), columns=['bar'],\\n index=range(len(epochs)))\\nepochs.metadata = new_metadata\\nepochs.metadata.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Calculate the derivative with respect to v\\n\\nprint(\\\"The partial derivative with respect to u: \\\", v.grad)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nthe expression is given by:\\n$\\\\frac{\\\\mathrm{\\\\partial f(u,v)}}{\\\\partial {u}}=v+2u$\\n$\\\\frac{\\\\mathrm{\\\\partial f(u=1,v=2)}}{\\\\partial {u}}=2+2(1)=4$\\n\\n\\nNow, take the derivative with respect to v<\\/code>:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"BA网络\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport networkx as nx\\nimport matplotlib.pyplot as plt\\nBA= nx.random_graphs.barabasi_albert_graph(200,2) #生成n=20、m=1的BA无标度网络\\npos = nx.spring_layout(BA) #定义一个布局，此处采用了spring布局方式\\nnx.draw(BA,pos,with_labels=False,node_size = 30) #绘制图形\\nplt.show()\\n\\nplotDegreeDistribution(BA)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"ClinVar documentation\\nSubmission guidelines can be found here, in particular note the requirement:\\n\\na valid description of the variant, one of:\\n * an HGVS expression\\n * chromosome coordinates and change\\n * cytogenetic description\\n\\nAlso found the xsd for ClinVar XML submissions, which includes all possible measure types:\\nxml\\n<xs:simpleType name=\\\"Measuretype\\\">\\n <xs:restriction base=\\\"xs:string\\\">\\n <xs:enumeration value=\\\"Gene\\\"\\/>\\n <xs:enumeration value=\\\"Variation\\\"\\/>\\n <xs:enumeration value=\\\"Insertion\\\"\\/>\\n <xs:enumeration value=\\\"Mobile element insertion\\\"\\/>\\n <xs:enumeration value=\\\"Novel sequence insertion\\\"\\/>\\n <xs:enumeration value=\\\"Microsatellite\\\"\\/>\\n <xs:enumeration value=\\\"Deletion\\\"\\/>\\n <xs:enumeration value=\\\"single nucleotide variant\\\"\\/>\\n <xs:enumeration value=\\\"Multiple nucleotide variation\\\"\\/>\\n <xs:enumeration value=\\\"Indel\\\"\\/>\\n <xs:enumeration value=\\\"Duplication\\\"\\/>\\n <xs:enumeration value=\\\"Tandem duplication\\\"\\/>\\n <xs:enumeration value=\\\"copy number loss\\\"\\/>\\n <xs:enumeration value=\\\"copy number gain\\\"\\/>\\n <xs:enumeration value=\\\"protein only\\\"\\/>\\n <xs:enumeration value=\\\"Inversion\\\"\\/>\\n <xs:enumeration value=\\\"Translocation\\\"\\/>\\n <xs:enumeration value=\\\"Interchromosomal breakpoint\\\"\\/>\\n <xs:enumeration value=\\\"Intrachromosomal breakpoint\\\"\\/>\\n <xs:enumeration value=\\\"Complex\\\"\\/>\\n <\\/xs:restriction>\\n<\\/xs:simpleType>\\nCompare measure types we've actually found in the data, here.\\nFilter\\nFilter full dataset to get just a manageable (hopefully representative) sample of records with measures representing complex events\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncomplex_xml = os.path.join(PROJECT_ROOT, 'complex-events.xml.gz')\\n\\n# get just \\\"complex events\\\"\\n# Q: what's complex? -- complex == no full coordinates\\ndef complex_measures(x):\\n if x.measure:\\n return (\\n # smattering of all non SNV variants\\n (x.measure.variant_type.lower() not in {'single nucleotide variant'} and np.random.random() < 0.01)\\n # be sure to get the rare ones\\n or (x.measure.variant_type.lower() in {'tandem duplication', 'fusion', 'complex', 'translocation', 'inversion'})\\n )\\n return False\\n\\nfilter_xml(\\n input_xml=clinvar_path,\\n output_xml=complex_xml,\\n filter_fct=complex_measures,\\n)\\n\\ndataset = ClinVarDataset(complex_xml)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Physique.ipynb\\\".\\nThe first task is:\\nThen the attributes can accessed by the column names.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(lbf2N.Toconvertfrom)\\nprint(lbf2N.to)\\nprint(lbf2N.Multiplyby)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.21\\/_downloads\\/80342e62fc31882c2b53e38ec1ed14a6\\/plot_background_filtering.ipynb\\\".\\nThe first task is:\\nNow we have very sharp frequency suppression, but our filter rings for the\\nentire 10 seconds. So this naïve method is probably not a good way to build\\nour low-pass filter.\\nFortunately, there are multiple established methods to design FIR filters\\nbased on desired response characteristics. These include:\\n1. The Remez_ algorithm (:func:`scipy.signal.remez`, `MATLAB firpm`_)\\n2. Windowed FIR design (:func:`scipy.signal.firwin2`,\\n :func:`scipy.signal.firwin`, and `MATLAB fir2`_)\\n3. Least squares designs (:func:`scipy.signal.firls`, `MATLAB firls`_)\\n4. Frequency-domain design (construct filter in Fourier\\n domain and use an :func:`IFFT <numpy.fft.ifft>` to invert it)\\n\\n
Note<\\/h4>Remez and least squares designs have advantages when there are\\n \\\"do not care\\\" regions in our frequency response. However, we want\\n well controlled responses in all frequency regions.\\n Frequency-domain construction is good when an arbitrary response\\n is desired, but generally less clean (due to sampling issues) than\\n a windowed approach for more straightforward filter applications.\\n Since our filters (low-pass, high-pass, band-pass, band-stop)\\n are fairly simple and we require precise control of all frequency\\n regions, we will primarily use and explore windowed FIR design.<\\/p><\\/div>\\n\\nIf we relax our frequency-domain filter requirements a little bit, we can\\nuse these functions to construct a lowpass filter that instead has a\\ntransition band, or a region between the pass frequency $f_p$\\nand stop frequency $f_s$, e.g.:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntrans_bandwidth = 10 # 10 Hz transition band\\nf_s = f_p + trans_bandwidth # = 50 Hz\\n\\nfreq = [0., f_p, f_s, nyq]\\ngain = [1., 1., 0., 0.]\\nax = plt.subplots(1, figsize=third_height)[1]\\ntitle = '%s Hz lowpass with a %s Hz transition' % (f_p, trans_bandwidth)\\nplot_ideal_filter(freq, gain, ax, title=title, flim=flim)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1.1 Model for one patient recieving a single dose\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Simulate data\\nstates = ode_map(k1 = theta[0], k2 = theta[1])\\nsigma = 0.1\\nlog_y = sigma * random.normal(random.PRNGKey(37272710), (states.shape[0],)) \\\\\\n + jnp.log(states)\\n\\ny = jnp.exp(log_y)\\n# print(y)\\n\\nfigure(figsize = [6, 6])\\nplot(t[1:], states)\\nplot(t[1:], y, 'o')\\nshow()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# dipo_min = dipo[phi_min, gam_min, the_min]\\n# dipo_ci = dipo[phi_ci, gam_ci, the_ci]\\n# difference_dipo = dipo_ci - dipo_min\\n\\n# for i in range(8):\\n# permanent = difference_dipo[:,i,i]\\n# print('S_{} -> {}'.format(i,permanent))\\n\\n# dipo_min[:,1,2],dipo_min[:,0,1],dipo_min[:,0,6],dipo_min[:,0,3],dipo_min[:,0,2],dipo_min[:,0,7]\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nHere I check the direction of the permanent dipoles.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!python test.py --reconstruct --data data\\/yelp\\/test.txt --output test.rec --checkpoint checkpoints\\/yelp\\/daae\\/\\n\\n\\n\\n!ls checkpoints\\/yelp\\/daae\\n\\n!head checkpoints\\/yelp\\/daae\\/test.rec.rec\\n\\n!head checkpoints\\/yelp\\/daae\\/test.rec.z\\n\\n!head data\\/yelp\\/test.txt\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nReconstruction\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"DIVISÃO EM ZONA RURAL E URBANA, A SEGUNDA VARIÁVEL DE ANÁLISE\\n\",\"targets\":\"base.loc[(base.V4105<4),\\\"ZONA\\\"]=\\\"Urbana\\\"\\nbase.loc[(base.V4105>3),\\\"ZONA\\\"]=\\\"Rural\\\"\\nbase.ZONA=base.ZONA.astype(\\\"category\\\")\\n\\nbase9.loc[(base9.V4105<4),\\\"ZONA\\\"]=\\\"Urbana\\\"\\nbase9.loc[(base9.V4105>3),\\\"ZONA\\\"]=\\\"Rural\\\"\\nbase9.ZONA=base9.ZONA.astype(\\\"category\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Although C gets more than half of the PageRank for itself, the effect has been limited.\\nNote that for a random surfer, there are three path to move:\\n\\n\\nfollow a link.\\n\\n\\nteleport to a random page. $\\\\gets$ taxation\\n\\n\\ngoes nowhere. $\\\\gets$ dead ends\\n\\n\\nSince there will always be some fraction of a surfer operating on the Web, so even if there are dead ends, the sum of the ocmponents of $v$ may be less than 1, but it will never reacher 0.\\n5.1.6 Using PageRank in a Search Engine\\n\\n\\nfind the qualified pages, which have at least one of the search terms in the query.\\n\\n\\ncalculate a score for those pages, including PageRank.\\n\\n\\n5.1.7 Exercises\\n5.1.1\\n略\\n5.1.2\\n略\\n5.1.3\\n$n$ nodes: 1\\/n \\nthe additional node: n * 1\\/n * 1\\/n = 1\\/n\\n5.1.4\\ntodo\\n5.1.5\\n略\\n5.1.6\\nthe first node: 1 \\nthe left nodes: 1\\/2\\n5.1.7\\nroot: 1 \\nheight = 1: 1\\/3 \\nheight = 2: 1\\/3 * 1\\/2 \\nheight = k: $\\\\frac{1}{3} \\\\times (\\\\frac{1}{2})^{k-1}, k > 1$\\n5.2 Efficient Computation of PageRank\\nPageRank: matrix-vector multiplicaton $\\\\to$ MapReduce. \\nHowever, we must deal with two issues:\\n\\n\\n$M$ is very sparse. \\n list its nonzero elements.\\n\\n\\nwe may wish to use a combiner to reduce the amount of data (Map $\\\\to$ Reduce). \\n striping approach.\\n\\n\\n5.2.1 Representing Transition Matrices\\nThe proper way to represent any sparse matrix is to list the locations and values of the nonzero entries. \\nThe space needed is linear in the number of nonzero entries.\\nRepresent a column by: \\n 1. one integer for the out-degree, \\n 2. one integer for rowname per nonzero entry.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmatrix_5_1\\n\\nimport string\\n\\ndf_M = pd.DataFrame(matrix_5_1, index=list(string.uppercase[0:4]), columns=list(string.uppercase[0:4]))\\ndf_M\\n\\ndef compact_representation_of_sparse_matrix(df):\\n \\\"\\\"\\\"It is introduced in Example 5.7\\\"\\\"\\\"\\n \\n degree = df.apply(np.count_nonzero, axis=0) \\n \\n dest = df.apply(np.nonzero, axis=0) \\n dest = dest.apply(lambda x: x[0])\\n \\n return pd.concat([degree, dest], axis=1, keys=['Degree', 'Destinations']) \\n \\n \\ncompact_representation_of_sparse_matrix(df_M)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Varianz<\\/b> \\nVarianz ist ein Streumaß, das uns eine Einschätzung erlaubt, wie sehr die Daten vom Mittelwert abweichen. Offensichtlich haben die Datenreihen [6,6,6,6] und [1,11,2,10] den gleichen Mittelwert, aber eine ganz unterschiedliche Varianz. Berechnet wird die Varianz einer Population folgendermaßen:\\n$$\\nv = \\\\sum_{i=0}^n \\\\frac {(\\\\mu - x_i)^2} {n}\\n$$\\nDie Quadrierung der Werte ist notwendig, um zu vermeiden, dass sich positive und negative Werte gegenseitig aufwiegen. Allerdings erschwert die Quadrierung die Interpretation einer Varianz (Wenn wir die Varianz der Körpergröße gemessen in cm anschauen, dann haben wir einen Wert in Quadratzentimeter vor uns...), außerdem sind die Werte recht groß.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnp.var(data)\\n\\n\\na = [6,6,6,6] \\nb = [1,11,2,10]\\nprint(\\\"Mittelwert a: \\\", np.mean(a))\\nprint(\\\"Mittelwert b: \\\", np.mean(b))\\nprint(\\\"Varianz a: \\\", np.var(a))\\nprint(\\\"Varianz b: \\\", np.var(b))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# HMC - Unscaled\\nnsample = 10000\\nm = 20\\neps = .0001\\n#theta = np.zeros(p)\\ntheta = beta_true_unscale.copy()\\nphi = 0.01\\n\\nnp.random.seed(2)\\nsamples = np.zeros((nsample, p))\\nu = np.zeros(nsample)\\nfor i in range(nsample):\\n theta = hmc(Y, X, gradU, M, eps, m, theta, C, V)\\n samples[i] = theta\\n u[i] = U(theta, Y, X)\\n \\nnp.mean(samples, axis=0) - beta_true_unscale\\n\\nplt.plot((samples - beta_true_unscale)[:,4])\\nplt.show()\\n\\nplt.plot(u)\\nplt.show()\\n\\nbeta_true_unscale\\n\\n# HMC - Scaled\\nnsample = 10000\\nm = 20\\neps = .001\\ntheta = np.zeros(p)\\n#theta = beta_true_scale.copy()\\nphi = 0.1\\n\\nnp.random.seed(2)\\nsamples = np.zeros((nsample, p))\\nu = np.zeros(nsample)\\nfor i in range(nsample):\\n theta = hmc(Y, Xs, gradU, M, eps, m, theta, C, V)\\n samples[i] = theta\\n u[i] = U(theta, Y, Xs)\\n \\nnp.mean(samples, axis=0) - beta_true_scale\\n\\nplt.plot((samples - beta_true_scale)[:,1])\\nplt.show()\\n\\nplt.plot(u)\\nplt.show()\\n\\n# HMC - Scaled (no intercept)\\nnsample = 10000\\nm = 20\\neps = .001\\ntheta = np.zeros(p-1)\\n#theta = beta_true_scale.copy()[1:]\\nphi = 1\\n\\nnp.random.seed(2)\\nsamples = np.zeros((nsample, p-1))\\nu = np.zeros(nsample)\\nfor i in range(nsample):\\n theta = hmc(Y, Xs[:,1:], gradU, np.identity(p-1), eps, m, theta, C, V)\\n samples[i] = theta\\n u[i] = U(theta, Y, Xs[:,1:])\\n \\nnp.mean(samples, axis=0) - beta_true_scale[1:]\\n\\nplt.plot((samples - beta_true_scale[1:])[:,5])\\nplt.show()\\n\\nplt.plot(u)\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nOur code - HMC\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create a separate list for each review for the businesses that show up in the business_id list. Remove all reviews that relate to the current user.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nuser_id = user_reviews_json.keys()[29]\\nrest_reviews = []\\nrest_ratings = []\\nbiz_ids = []\\nfor i in tqdm.tqdm(range(0, len(restreview.keys()))):\\n for restaurant in restreview[restreview.keys()[i]]:\\n if restaurant['user_id'] != user_id:\\n rest_reviews.append(restaurant['text'])\\n rest_ratings.append(restaurant['stars'])\\n biz_ids.append(restreview.keys()[i])\\n else:\\n pass\\nrestaurant_df = pd.DataFrame({'review_text': rest_reviews, 'rating': rest_ratings, 'biz_id': biz_ids})\\n\\n#Feature objects and functions\\nstop_words = set(stopwords.words('english'))\\n\\ndef sent_percent(review):\\n regex_words = re.compile('[a-z]+')\\n words = [x.lower() for x in review.split(' ')]\\n words = [x for x in words if regex_words.match(x)]\\n pos_count, neg_count = 0, 0\\n for word in words:\\n if word in lh_pos:\\n pos_count += 1\\n elif word in lh_neg:\\n neg_count += 1\\n return [float(pos_count)\\/float(len(words)), float(neg_count)\\/float(len(words))]\\n\\npos_vectorizer = CountVectorizer(vocabulary = lh_pos)\\nneg_vectorizer = CountVectorizer(vocabulary = lh_neg)\\nclass SentimentPercentage(BaseEstimator, TransformerMixin):\\n \\\"\\\"\\\"Takes in two lists of strings, extracts the lev distance between each string, returns list\\\"\\\"\\\"\\n\\n def __init__(self):\\n pass\\n\\n def transform(self, reviews):\\n ##Take in a list of textual reviews and return a list with two elements:\\n ##[Positive Percentage, Negative Percentage]\\n pos_vect = pos_vectorizer.transform(reviews)\\n neg_vect = neg_vectorizer.transform(reviews)\\n features = []\\n \\n for i in range(0, len(reviews)):\\n sent_percentage = []\\n sent_percentage.append(float(pos_vect[i].sum())\\/float(len(reviews[i])))\\n sent_percentage.append(float(neg_vect[i].sum())\\/float(len(reviews[i])))\\n features.append(sent_percentage)\\n \\n return np.array(features)\\n\\n def fit(self, reviews, y=None, n_grams = None):\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create the model with the saltwater well (Simulation 2)\\n\",\"targets\":\"modelname2 = 'swiex4_s2'\\nml2 = mf.Modflow(modelname2, version='mf2005', exe_name=exe_name, model_ws=workspace)\\n\\ndiscret = mf.ModflowDis(ml2, nlay=nlay, nrow=nrow, ncol=ncol, laycbd=0,\\n delr=delr, delc=delc, top=botm[0], botm=botm[1:],\\n nper=nper, perlen=perlen, nstp=nstp)\\nbas = mf.ModflowBas(ml2, ibound=ibound, strt=ihead)\\nlpf = mf.ModflowLpf(ml2, laytyp=laytyp, hk=hk, vka=vka)\\nwel = mf.ModflowWel(ml2, stress_period_data=swwells_well_data)\\nghb = mf.ModflowGhb(ml2, stress_period_data=ghb_data)\\nrch = mf.ModflowRch(ml2, rech=rch_data)\\nswi = mf.ModflowSwi2(ml2, nsrf=1, istrat=1, toeslope=toeslope, tipslope=tipslope, nu=nu,\\n zeta=z, ssz=ssz, isource=iso, nsolver=1,\\n adaptive=adaptive, nadptmx=nadptmx, nadptmn=nadptmn,\\n nobs=nobs, iswiobs=iswiobs, obsnam=obsnam, obslrc=obslrc)\\noc = mf.ModflowOc(ml2, stress_period_data=spd)\\npcg = mf.ModflowPcg(ml2, hclose=1.0e-6, rclose=3.0e-3, mxiter=100, iter1=50)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\".ipynb_checkpoints\\/Data Analysis Project 3 - Data Wrangle OpenStreetMaps Data-checkpoint.ipynb\\\".\\nThe first task is:\\nReligions in Places of Worship\\nGrouping and sorting by the occurences of the religion attribute for all amenities classified as place_of_worship or community_center gives us an indication, how prevalent religions are in our city: obviously, christian is the most prevalent here.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom Project.notebook_stub import project_coll\\nimport pprint\\n\\n# Query used - see function: Project.audit_stats_map.stats_religions(...):\\npipeline = [\\n {\\\"$match\\\": {\\\"amenity\\\":{\\\"$in\\\": [\\\"place_of_worship\\\",\\\"community_center\\\"]}}},\\n {\\\"$group\\\": {\\\"_id\\\": \\\"$religion\\\", \\\"count\\\": {\\\"$sum\\\": 1}}},\\n {\\\"$sort\\\": {\\\"count\\\": -1}}\\n ]\\nl = list(project_coll.aggregate(pipeline))\\npprint.pprint(l)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"### Luke's Rabbits\\n# Luke loves his rabbits.\\n# However, they are breeding like crazy.\\n# Currently, he has 7 rabbits. Every month, they double. So next month he will have 14.\\n# Feeding each rabbit costs $10 dollars a month.\\n#\\n# The input should be how many months Luke wants to breed his rabbits.\\n# The output should be how much month it would cost to feed all of those rabbits that month.\\n\\nprint(\\\"\\\"\\\"Every month, the number of rabbits doubles.\\n If you tell me how many months you want to breed the rabbits,\\n then I will calculate how much money it will cost in food\\\"\\\"\\\")\\nnum_months = int(input(\\\"Number of months: \\\"))\\n# since it doubles every month, then 7 * 2 is the first month, 7 * 2 * 2 is the second\\n# so, it is 7 * 2 ** num_months\\nnum_rabbits = 7 * 2 ** num_months\\nfood_cost = 10*num_rabbits\\nprint(\\\"It will cost you {} dollars to feed your rabbits that month\\\".format(food_cost))\\n\\n### Bill's Money\\n# Bill wants to know how much money he can earn from saving.\\n# He has an investment account that gives him 10% every month\\n# He wants to know how much month he will have after 1, 3, and 6 months\\n#\\n# The input should be how much money he wants to invest.\\n# The output should be the numbers for each of the 3 lengths of time.\\n\\n### Sara's Army\\n# Sara wants to hire an army.\\n# It will cost her $500 per soldier.\\n#\\n# The input should be the amount of money that Sara has\\n# The output should be the number of soldiers she can get.\\n#\\n# Note that the amount of money she has may not be exactly the amount of a soldier\\n# For example, if she has $700 dollars, she can only get 1 soldier\\n# So, you will have to do floor division.\\n# See the slides if you forgot how\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise 2: Harder Formulas\\nI will provide a description of a problem.\\nIt is your job to convert that description into a formula.\\nThen, you must code that formula into an equation and code.\\nEach of the problems will require an input that I specify.\\nWrite an intro print statement explaining the situation for the problem.\\nThen write an input statement to get the relevant information.\\nFinally, use your equation to calculate the answer.\\nThen, print out the answer in a nice way.\\nI have completed the first one as an example.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"And you can find the max and min values of the array:\\n\",\"targets\":\"print('The minimum of `x` is `{0}`'.format(x.min()))\\n\\nprint('The maximum of `x` is `{0}`'.format(x.max()))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"GettingStartedCNN\\/CaffeOnDockerStable.ipynb\\\".\\nThe first task is:\\nNow we can visualize one by one as follows (Please note that the grayscale is inverse plotted<\\/span>):\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef plot_mnist_digit(image, title=None):\\n fig = plt.figure()\\n ax = fig.add_subplot(1,1,1)\\n \\n imgplot = ax.imshow(image[:,:,0], cmap=mpl.cm.Greys)\\n imgplot.set_interpolation('nearest')\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n \\n major_ticks = np.arange(0, 29, 7) \\n minor_ticks = np.arange(0, 28, 1) \\n\\n ax.set_xticks(major_ticks) \\n ax.set_xticks(minor_ticks, minor=True) \\n ax.set_yticks(major_ticks) \\n ax.set_yticks(minor_ticks, minor=True) \\n\\n# ax.grid(which='both',color='gray', linestyle='-',linewidth=0.5)\\n \\n if not title == None:\\n plt.title(title, fontsize=15) \\n plt.show()\\n \\ndigit = next(test_set)\\nlabel = digit[0]; image = digit[1]\\nplot_mnist_digit(image, \\\"LABEL: \\\" + str(label))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%cython\\n# cython: boundscheck = False\\n# cython: wraparound = False\\nfrom cpython.datetime cimport (\\n import_datetime, datetime_new, datetime, timedelta)\\nfrom pandas import Timestamp\\n\\nimport_datetime()\\n\\ncpdef convert_arrays_ts(\\n long[:] year, long[:] month, long[:] day, \\n long long[:] out):\\n \\\"\\\"\\\" Result goes into `out` \\\"\\\"\\\"\\n cdef int i, n = year.shape[0]\\n cdef datetime dt\\n for i in range(n):\\n dt = datetime_new(\\n year[i], month[i], day[i], 0, 0, 0, 0, None)\\n out[i] = Timestamp(dt).value\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWhat to do?\\nThe first thing is to check whether there is a low-level PXD interface file for the Python datetime object.\\n\\nLet's use Cython!\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"2. Feature Selection\\nBased on the result of explorative variable analysis, we already know that our response variable is normal-like distributed. And We select predictors whose missing rate is less than 25% roughly. Now we want to deal with our X variables: factorize categorical variables, figure out the importance of these variables and then select some of them as our final predictors.\\nAfter checking the meaning of these variables, the following variables are cateogircal: fips, propertylandusetypeid, regionidcounty. There are only three values in regionidcounty: 3101,1286 and 2061. So we just factorise it as 0,1 and 2. The value of propertyliandsetypeid are meaningless. And there are so many unique values, we need to sort them into larger classes based on their meanings and frequencies. And then, we use oneencode method to make them as dummy variables. Consider the property of fips(Federal Information Processing Standard code),we try to use this code to get the geography information of these properties.\\nTo figure out the relationship between logerror and other variables, we use xgboost model to see the importance of these variables. We use correlation matrix to see whether some variables are basically independent with logerror in the beginning, but the result shows that their correlations with logerror are so similar that we can't tell which one is larger. So, we use this way to do some digging. The code part is very similar as the xgboost model we build, therefore we omit them and simply explain the result. Here the dataset we use includes all the variables in case some extremely important variables will be omitted by the rough selection. All the missing values are filled as -999. The first 10 important variables are 'finishedfloor1squarefeet','numberofstories','regionidcity','poolcnt','regionidzip','buildingclasstypeid','calculatedbathnbr','fireplacecnt','taxdelinquencyflag','pooltypeid10'. These variables involves different aspects of housing situations, like location, housewares, housing size, interior...\\n\",\"targets\":\"X = pd.read_table('adjustedinput\\/mode\\/x_train_mode.csv',sep=',')\\nX = X.iloc[:,1:]\\ny = pd.read_csv('adjustedinput\\/train_y.csv')\\nX_train = scale(X)\\ny_train = np.array(y).ravel()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"5. Create a linear regression model based on the available data to predict the mortality rate given a level of exposure\\n\",\"targets\":\"lm = smf.ols(formula=\\\"Mortality~Exposure\\\",data=df).fit()\\nlm.params\\n\\ndef exposure_predict(exposure):\\n df = pd.read_csv(\\\"data\\/hanford.csv\\\")\\n lm = smf.ols(formula=\\\"Mortality~Exposure\\\",data=df).fit()\\n mortality = exposure * lm.params.Exposure + lm.params.Intercept\\n return mortality\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# PROPERTY ID - DO NOT EDIT ! \\nDOC.set_id('cmip6.land.energy_balance.evaporation') \\n\\n# PROPERTY VALUE(S): \\n# Set as follows: DOC.set_value(\\\"value\\\") \\n# Valid Choices: \\n# \\\"alpha\\\" \\n# \\\"beta\\\" \\n# \\\"combined\\\" \\n# \\\"Monteith potential evaporation\\\" \\n# \\\"Other: [Please specify]\\\" \\n# TODO - please enter value(s)\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n18.4. Evaporation\\nIs Required: TRUE Type: ENUM Cardinality: 1.N\\nSpecify the formulation method for land surface evaporation, from soil and vegetation\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# PROPERTY ID - DO NOT EDIT ! \\nDOC.set_id('cmip6.ocnbgchem.tracers.nitrous_species_if_N') \\n\\n# PROPERTY VALUE(S): \\n# Set as follows: DOC.set_value(\\\"value\\\") \\n# Valid Choices: \\n# \\\"Nitrates (NO3)\\\" \\n# \\\"Amonium (NH4)\\\" \\n# \\\"Other: [Please specify]\\\" \\n# TODO - please enter value(s)\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n8.4. Nitrous Species If N\\nIs Required: FALSE Type: ENUM Cardinality: 0.N\\nIf nitrogen present, list nitrous species.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"+= je vlastne priradenie a teda spravi z premennych count a total lokalne premenne, pricom ich chce hned predtym aj pouzit\\nPripominam, ze predchadzajuci priklad nepriradzoval do premennej, len upravoval mutable objekt.\\nPodobne ako uplne na zaciatku bol riesenim prikaz global, teraz to bude nonlocal\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef make_averager():\\n count = 0\\n total = 0\\n def averager(new_value):\\n nonlocal count, total # tieto dve premenne teda nebudu lokalne v ramci funkcie averager \\n # ale sa zoberu z funkcie o uroven vyssie\\n count += 1\\n total += new_value\\n return total \\/ count\\n return averager\\n\\navg = make_averager()\\navg(10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"P4.3_Flopy_Hubbertville_areal_model.ipynb\\\".\\nThe first task is:\\nWhy is there less water in the system than when the gw divide was not simulated with no-flow cells?\\nNote that this problem is harder to solve. To see non-convergence in MODFLOW, set the dampening in block In [36] to 1.0\\nNow let's try a specified head for the groundwater divide\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Rows 10 and 11 had highest heads; reset Row 10 and 11 to a specified head boundary (set that row to -1 in the MODFLOW IBOUND array)\\nIBOUND[:, 10, :] = -1 \\nIBOUND[:, 11, :] = -1 \\nprint IBOUND\\n\\n#MODFLOW uses the starting heads to set the specified head boundary elevations\\n#we need to reset the starting heads in Rows 10 and 11 to what they were originally\\n#recall we saved these heads, and can print them to check\\nprint \\\"Row 10 heads =\\\", ROW10_HEAD\\nprint \\\"Row 11 heads =\\\", ROW11_HEAD\\n\\nSTRT[:, 10, :] = ROW10_HEAD # setting starting heads Row 10 to heads calculated in Part a.\\nSTRT[:, 11, :] = ROW11_HEAD # setting starting heads Row 10 to heads calculated in Part a.\\nprint STRT\\n\\n#we have to update the MODFLOW's BAS Package with the new STRT heads \\nBAS_PACKAGE = flopy.modflow.ModflowBas(MF, ibound=IBOUND, strt=STRT)\\n\\n#delete old files to prevent us from reading old results\\nmodelfiles = os.listdir(modelpath)\\nfor filename in modelfiles:\\n f = os.path.join(modelpath, filename)\\n if modelname in f:\\n try:\\n os.remove(f)\\n print 'Deleted: ', filename\\n except:\\n print 'Unable to delete: ', filename\\n\\n#Now write the model input files\\nMF.write_input()\\nprint \\\"New MODFLOW input files = \\\", modelfiles\\nprint \\\"You can check the newly created files in\\\", modelpath\\n\\n\\n#rerun MODFLOW-2005\\nsilent = False #Print model output to screen?\\npause = False #Require user to hit enter? Doesn't mean much in Ipython notebook\\nreport = True #Store the output from the model in buff\\nsuccess, buff = MF.run_model(silent=silent, pause=pause, report=report)\\n\\n#As before, let's look at the results and compare to P4-3 Part a.\\n#imports for plotting and reading the MODFLOW binary output file\\nimport matplotlib.pyplot as plt\\nimport flopy.utils.binaryfile as bf\\n\\n#Create the headfile object and grab the results for last time.\\nheadfile = os.path.join(modelpath, modelname + '.hds')\\nheadfileobj = bf.HeadFile(headfile)\\n\\n#Get a list of times that are contained in the model\\ntimes =...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"(3b) Mean using reduce \\nFind the mean number of words per unique word in wordCounts.\\nUse a reduce() action to sum the counts in wordCounts and then divide by the number of unique words. First map() the pair RDD wordCounts, which consists of (key, value) pairs, to an RDD of values.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# TODO: Replace with appropriate code\\nfrom operator import add\\n\\ntotalCount = (wordCounts\\n .map(lambda (a,b): b)\\n .reduce(add))\\naverage = totalCount \\/ float(wordCounts.distinct().count())\\nprint totalCount\\nprint round(average, 2)\\n\\n# TEST Mean using reduce (3b)\\nTest.assertEquals(round(average, 2), 1.67, 'incorrect value of average')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"##test:\\nf.reset()\\nDataSource.set_source('frame-1')\\nf.input_all()\\n\\n##test:\\nvars(f.rawdata)\\n\\n##test:\\nf.rawdata.nodes\\n\\n##test:\\nf.members\\n\\n##test:\\nDataSource.DATASOURCE.celldata\\n\\n##test:\\nDataSource.DATASOURCE.tables\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nInput From Files\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Daju sa tiez spravit aj tabulky s vyssimi dimenziami. Tam sa ale uz velmi rychlo straca prehladnost\\n\",\"targets\":\"pd.crosstab(index=titanic[\\\"Survived\\\"], \\n columns=[titanic[\\\"Pclass\\\"], titanic[\\\"Sex\\\"]],\\n margins=True)\\n\\n\\npd.crosstab(index=titanic[\\\"Survived\\\"], \\n columns=[titanic[\\\"Pclass\\\"], titanic[\\\"Sex\\\"], titanic[\\\"Embarked\\\"]],\\n margins=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Assemble matrices\\nA = inner(grad(v), -grad(u))\\nG = inner(div(v), p)\\nD = inner(q, div(u))\\n\\n# Create Block matrix\\nsol = la.BlockMatrixSolver(A+G+D)\\n\\n# Functions to hold solution and rhs\\nup_hat = Function(VQ).set_boundary_dofs()\\nfh_hat = Function(VQ)\\n\\n# Solve Stokes problem. Note constraint for pressure\\nup_hat = sol(fh_hat, u=up_hat, constraints=((2, 0, 0),)) \\n\\n# Move solution to Array in real space\\nup = up_hat.backward()\\nu_, p_ = up\\n\\nX = Q.local_mesh(True)\\nplt.quiver(X[0], X[1], u_[0], u_[1])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nImplementation Stokes - matrices and solve\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Contribution Ratio\\n\",\"targets\":\"#@title Evaluate contribution\\/attribution ratio { vertical-output: true, display-mode: \\\"form\\\" }\\n\\ndf_contrib = pd.DataFrame(df['Attributed Media Source'].value_counts())\\\\\\n .join(pd.DataFrame(df['Contributor 1 Media Source'].value_counts()),how='outer')\\\\\\n .join(pd.DataFrame(df['Contributor 2 Media Source'].value_counts()),how='outer')\\\\\\n .join(pd.DataFrame(df['Contributor 3 Media Source'].value_counts()),how='outer').fillna(0)\\n\\ndf_contrib['Contributions']= df_contrib[list(df_contrib.columns)[1:]].sum(axis=1)\\ndf_contrib['Ratio']=df_contrib['Contributions'] \\/ df_contrib['Attributed Media Source']\\n\\ndf_contrib=df_contrib.sort_values(by=['Attributed Media Source'],ascending=False)\\ndf_contrib.style.format({'Attributed Media Source':\\\"{:,}\\\",\\\\\\n 'Contributor 1 Media Source':\\\"{:,}\\\",\\\\\\n 'Contributor 2 Media Source':\\\"{:,}\\\",\\\\\\n 'Contributor 3 Media Source':\\\"{:,}\\\",\\\\\\n 'Contributions':\\\"{:,}\\\",\\\\\\n 'Ratio': \\\"{:.2%}\\\"})\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create the plots with interact\\nHere we repeat the plots, but now using IPython interact. This allow us to change unput parameters and see the result in the plot.\\n\",\"targets\":\"@interact(Pt_dBm=(0., 40., 5.), noise_power_dBm=(-160., 0.0, 5.), pl_model=['nothing', '3gpp', 'free_space', 'metis'], ap_decimation=['1', '2', '4', '9'])\\ndef plot_SINRs(Pt_dBm=30., noise_power_dBm=-160, pl_model='3gpp', ap_decimation=1):\\n scenario_params = {\\n 'side_length': 10, # 10 meters side length\\n 'single_wall_loss_dB': 5,\\n 'num_rooms_per_side': 12,\\n 'ap_decimation': int(ap_decimation)}\\n \\n power_params = {\\n 'Pt_dBm': Pt_dBm, # 20 dBm transmit power\\n 'noise_power_dBm': noise_power_dBm # Very low noise power\\n }\\n \\n out = perform_simulation_SINR_heatmap(scenario_params, power_params)\\n\\n (sinr_array_pl_nothing_dB,\\n sinr_array_pl_3gpp_dB,\\n sinr_array_pl_free_space_dB,\\n sinr_array_pl_metis_ps7_dB) = out\\n \\n \\n #sinr_array_pl_nothing_dB, sinr_array_pl_3gpp_dB, sinr_array_pl_free_space_dB, sinr_array_pl_metis_ps7_dB = calc_SINRs(Pt_dBm, noise_var)\\n\\n fig, ax = plt.subplots(figsize=(10, 8))\\n \\n if pl_model == 'nothing': \\n im = ax.imshow(sinr_array_pl_nothing_dB2, interpolation='nearest', vmax=-1.5, vmin=-5.)\\n fig.colorbar(im)\\n plt.show()\\n print((\\\"Min\\/Mean\\/Max SINR value (no PL):\\\"\\n \\\"\\\\n {0}\\\\n {1}\\\\n {2}\\\").format(\\n sinr_array_pl_nothing_dB.min(),\\n sinr_array_pl_nothing_dB.mean(),\\n sinr_array_pl_nothing_dB.max()))\\n elif pl_model == '3gpp':\\n im = ax.imshow(sinr_array_pl_3gpp_dB2, interpolation='nearest', vmax=30, vmin=-2.5)\\n fig.colorbar(im)\\n ax.set_title('ka')\\n plt.show()\\n print((\\\"Min\\/Mean\\/Max SINR value (3GPP):\\\"\\n \\\"\\\\n {0}\\\\n {1}\\\\n {2}\\\").format(\\n sinr_array_pl_3gpp_dB.min(),\\n sinr_array_pl_3gpp_dB.mean(),\\n sinr_array_pl_3gpp_dB.max()))\\n elif pl_model == 'free_space':\\n im = ax.imshow(sinr_array_pl_free_space_dB2, interpolation='nearest', vmax=30, vmin=-2.5)\\n fig.colorbar(im)\\n plt.show()\\n print((\\\"Min\\/Mean\\/Max SINR...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Instantiate Model\\nmPrimal_Standard_GUROBI = gbp.Model(' -- Standard Primal Linear Programming Problem -- ')\\n\\n# Set Focus to Optimality\\ngbp.setParam('MIPFocus', 2)\\n\\n# Decision Variables\\ndesc_var = []\\nfor dest in cols:\\n desc_var.append([])\\n desc_var[dest].append(mPrimal_Standard_GUROBI.addVar(vtype=gbp.GRB.CONTINUOUS, \\n name='y'+str(dest+1)))\\n\\n# Surplus Variables\\nsurp_var = []\\nfor orig in rows:\\n surp_var.append([])\\n surp_var[orig].append(mPrimal_Standard_GUROBI.addVar(vtype=gbp.GRB.CONTINUOUS, \\n name='s'+str(orig+1)))\\n\\n# Update Model\\nmPrimal_Standard_GUROBI.update()\\n\\n#Objective Function\\nmPrimal_Standard_GUROBI.setObjective(gbp.quicksum(Cj[dest]*desc_var[dest][0] \\n for dest in cols), \\n gbp.GRB.MINIMIZE)\\n\\n# Constraints\\nfor orig in rows:\\n mPrimal_Standard_GUROBI.addConstr(gbp.quicksum(Aij[orig][dest]*desc_var[dest][0] \\n for dest in cols) \\n - surp_var[orig][0] \\n - Bi[orig] == 0)\\n\\n# Optimize\\nmPrimal_Standard_GUROBI.optimize()\\n# Write LP file\\nmPrimal_Standard_GUROBI.write('LP.lp')\\nprint '\\\\n*************************************************************************'\\nprint ' | Decision Variables'\\nfor v in mPrimal_Standard_GUROBI.getVars():\\n print ' | ', v.VarName, '=', v.x\\nprint '*************************************************************************'\\nval = mPrimal_Standard_GUROBI.objVal\\nprint ' | Objective Value ------------------ ', val\\nprint ' | Aij Sum -------------------------- ', AijSum\\nprint ' | Cj Sum --------------------------- ', CjSum\\nprint ' | Bi Sum --------------------------- ', BiSum\\nprint ' | Matrix Dimensions ---------------- ', Aij.shape\\nprint ' | Date\\/Time ------------------------ ', dt.datetime.now()\\nprint '*************************************************************************'\\nprint '-- Gurobi Standard Primal...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n1. Primal<\\/u><\\/b><\\/font>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"04-python-prat\\/data_science\\/Python and Data Science.ipynb\\\".\\nThe first task is:\\nSciKit Learn (http:\\/\\/scikit-learn.org)\\n\\nBiblioteca Python para mineração e análise de dados\\n\\nComo instalar\\n\\nAnaconda (http:\\/\\/pandas.pydata.org\\/pandas-docs\\/stable\\/install.html#installing-pandas-with-anaconda)\\nDownload anaconda: https:\\/\\/www.continuum.io\\/downloads\\nInstalar Anaconda: https:\\/\\/docs.continuum.io\\/anaconda\\/install\\nDisponível para osx-64, linux-64, linux-32, win-64, win-32 e Python 2.7, Python 3.4, e Python 3.5\\nconda install scikit-learn\\n\\n\\nPip\\npip install -U scikit-learn\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom sklearn.tree import DecisionTreeClassifier\\nfrom sklearn.metrics import confusion_matrix\\nfrom sklearn.cross_validation import train_test_split\\nimport pickle\\nimport time\\ntime1=time.strftime('%Y-%m-%d_%H-%M-%S')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"1 Creating an instance of the solow.Model class\\nIn this notebook I will walk you through the creation of an instance of the solow.Model class. To create an instance of the solow.Model we must define two primitives: an aggregate production function and a dictionary of model parameter values.\\n1.1 Defining the production function $F$:\\nAt each point in time the economy in a Solow growth model has some amounts of capital, $K$, labor, $L$, and knowledge (or technology), $A$, that can be combined to produce output, $Y$, according to some function, $F$:\\n$$ Y(t) = F(K(t), A(t)L(t)) \\\\tag{1.1.1} $$\\nwhere $t$ denotes time. Note that $A$ and $L$ are assumed to enter multiplicatively. Typically $A(t)L(t)$ denotes \\\"effective labor\\\", and technology that enters in this fashion is known as labor-augmenting or \\\"Harrod neutral.\\\"\\nA key assumption of the model is that the function $F$ exhibits constant returns to scale in capital and labor inputs. Specifically,\\n$$ F(cK(t), cA(t)L(t)) = cF(K(t), A(t)L(t)) = cY(t) \\\\tag {1.1.2} $$\\nfor any $c \\\\ge 0$. For reference, the above information is contained in the docstring of the solow.Model.output attribute.\\n\",\"targets\":\"solow.Model.output?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Attributes and functions\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nrtre.get_tip_labels() # list of labels in node-plot order\\nrtre.get_tip_coordinates() # array of tip plot coordinates in idx order\\nrtre.get_node_values() # list in node-plot order\\nrtre.get_node_dict() # dict mapping idx:name for each tip\\nrtre.get_node_coordinates() # array of node plot coordinates in idx order\\nrtre.get_edge_values() # list of edge values in edge plot order\\nrtre.get_edge_values_mapped(); # list of edge values with mapped dict in edge plot order\\n\\nrtre.is_bifurcating() # boolean\\nrtre.is_rooted(); # boolean\\n\\nrtre.nnodes # number of nodes in the tree\\nrtre.ntips # number of tips in the tree\\nrtre.newick # the newick representation of the tree\\nrtre.features # list of node features that can be accessed \\nrtre.style; # dict of plotting style of tree\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Day_01\\/01_Pandas\\/3. Plotting and Visualization.ipynb\\\".\\nThe first task is:\\nThere are algorithms for determining an \\\"optimal\\\" number of bins, each of which varies somehow with the number of observations in the data series.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nsturges = lambda n: int(log2(n) + 1)\\nsquare_root = lambda n: int(sqrt(n))\\nfrom scipy.stats import kurtosis\\ndoanes = lambda data: int(1 + log(len(data)) + log(1 + kurtosis(data) * (len(data) \\/ 6.) ** 0.5))\\n\\nn = len(titanic)\\nsturges(n), square_root(n), doanes(titanic.fare.dropna())\\n\\ntitanic.fare.hist(bins=doanes(titanic.fare.dropna()))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"2.5. Create Main Zeropoints Directory (if it does not already exist)...\\n\",\"targets\":\"# Create main Zeropoints directory, if it does not already exist...\\nif not os.path.exists(zeropoints_dir):\\n os.makedirs(zeropoints_dir)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Turn a Unicode string to plain ASCII, thanks to http:\\/\\/stackoverflow.com\\/a\\/518232\\/2809427\\ndef unicode_to_ascii(s):\\n return ''.join(\\n c for c in unicodedata.normalize('NFD', s)\\n if unicodedata.category(c) != 'Mn'\\n )\\n\\n# Lowercase, trim, and remove non-letter characters\\ndef normalize_string(s):\\n s = unicode_to_ascii(s.lower().strip())\\n s = re.sub(r\\\"([,.!?])\\\", r\\\" \\\\1 \\\", s)\\n s = re.sub(r\\\"[^a-zA-Z,.!?]+\\\", r\\\" \\\", s)\\n s = re.sub(r\\\"\\\\s+\\\", r\\\" \\\", s).strip()\\n return s\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nReading and decoding files\\nThe files are all in Unicode, to simplify we will turn Unicode characters to ASCII, make everything lowercase, and trim most punctuation.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And now we can run the sampler:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport emcee\\n\\nwith model:\\n # First we work out the shapes of all of the deterministic variables\\n res = pm.find_MAP()\\n vec = model.bijection.map(res)\\n initial_blobs = log_prob_func(vec)[1:]\\n dtype = [(var.name, float, np.shape(b)) for var, b in zip(model.deterministics, initial_blobs)]\\n \\n # Then sample as usual\\n coords = vec + 1e-5 * np.random.randn(25, len(vec))\\n nwalkers, ndim = coords.shape\\n sampler = emcee.EnsembleSampler(nwalkers, ndim, log_prob_func, blobs_dtype=dtype)\\n sampler.run_mcmc(coords, 5000, progress=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1.b. Transforming dataset to a supervised learning problem\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndataset = read_csv('.\\/pollution.csv', header=0, index_col=0)\\nvalues = dataset.values\\n# specify columns to plot\\ngroups = [0, 1, 2, 3, 5, 6, 7]\\ni = 1\\n# plot each column\\npyplot.figure(figsize=(20,15))\\nfor group in groups:\\n pyplot.subplot(len(groups), 1, i)\\n pyplot.plot(values[:, group])\\n pyplot.title(dataset.columns[group], y=0.5, loc='right')\\n i += 1\\npyplot.show()\\n\\n# Can do it manually but efficient to create a function to transform a series to a supervised problem\\n# The function's key components:\\n# -the pandas shift() function and how it can be used to automatically define supervised learning datasets from time series data.\\n# -reframe a univariate time series into one-step and multi-step supervised learning problems.\\n# -reframe multivariate time series into one-step and multi-step supervised learning problems.\\n\\ndef series_to_supervised(data, n_in=1, n_out=1, dropnan=True):\\n n_vars = 1 if type(data) is list else data.shape[1]\\n df = DataFrame(data)\\n cols, names = list(), list()\\n# input sequence (t-n, ... t-1)\\n for i in range(n_in, 0, -1):\\n cols.append(df.shift(i))\\n names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]\\n# forecast sequence (t, t+1, ... t+n)\\n for i in range(0, n_out):\\n cols.append(df.shift(-i))\\n if i == 0:\\n names += [('var%d(t)' % (j+1)) for j in range(n_vars)]\\n else:\\n names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]\\n# put it all together\\n agg = concat(cols, axis=1)\\n agg.columns = names\\n# drop rows with NaN values\\n if dropnan:\\n agg.dropna(inplace=True)\\n return agg\\n\\n# integer encode direction\\nencoder = LabelEncoder()\\nvalues[:,4] = encoder.fit_transform(values[:,4])\\n# ensure all data is float\\nvalues = values.astype('float32')\\n# normalize features\\nscaler = MinMaxScaler(feature_range=(0, 1))\\nscaled = scaler.fit_transform(values)\\n# frame as supervised learning\\nreframed = series_to_supervised(scaled, 1, 1)\\n# drop columns we don't want to...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Practicas\\/practica3\\/simbolico.ipynb\\\".\\nThe first task is:\\nHe guardado todas las matrices de transformación homgénea en un solo arreglo, de tal manera que puedo hacer una función que tome todas las transformaciones de cada eslabon, y me devuelva las transformaciones a cada articulacion:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef transf_art(transformaciones):\\n from sympy import eye, simplify\\n Hs = [eye(4)]\\n for trans in transformaciones:\\n Hs.append(simplify(Hs[-1]*trans))\\n \\n return Hs[1:]\\n\\nHs = transf_art(As)\\nHs\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A lambda function can be assigned to a variable which makes this variable callable.\\n\",\"targets\":\"f = lambda x: x ** 2\\nf(2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2 - checking and Installing R binary in the right place\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# checking it's the official R\\nimport hashlib\\ndef give_hash(of_file, with_this):\\n with io.open(r_installer, 'rb') as f:\\n return with_this(f.read()).hexdigest() \\nprint (\\\" \\\"*12+\\\"MD5\\\"+\\\" \\\"*(32-12-3)+\\\" \\\"+\\\" \\\"*15+\\\"SHA-1\\\"+\\\" \\\"*(40-15-5)+\\\"\\\\n\\\"+\\\"-\\\"*32+\\\" \\\"+\\\"-\\\"*40)\\nprint (\\\"%s %s %s\\\" % (give_hash(r_installer, hashlib.md5) , give_hash(r_installer, hashlib.sha1),r_installer))\\nif give_hash(r_installer, hashlib.md5) == hashes[0] and give_hash(r_installer, hashlib.sha1) == hashes[1]:\\n print(\\\"looks good!\\\")\\nelse:\\n print(\\\"problem ! please check\\\")\\n assert give_hash(r_installer, hashlib.md5) == hashes[0]\\n assert give_hash(r_installer, hashlib.sha1) == hashes[1]\\n\\n# preparing Dos variables\\nos.environ[\\\"R_HOME\\\"] = os.environ[\\\"WINPYDIR\\\"]+ \\\"\\\\\\\\..\\\\\\\\tools\\\\\\\\R\\\\\\\\\\\" \\nos.environ[\\\"R_HOMEbin\\\"]=os.environ[\\\"R_HOME\\\"] + \\\"bin\\\" \\n\\n# for installation we need this\\nos.environ[\\\"tmp_Rbase\\\"]=os.path.join(os.path.split(os.environ[\\\"WINPYDIR\\\"])[0] , 'tools','R' ) \\nif 'amd64' in sys.version.lower():\\n r_comp ='\\/COMPONENTS=\\\"main,x64,translations'\\nelse:\\n r_comp ='\\/COMPONENTS=\\\"main,i386,translations'\\nos.environ[\\\"tmp_R_comp\\\"]=r_comp\\n\\n\\n# let's install it, if hashes do match\\nassert give_hash(r_installer, hashlib.md5) == hashes[0]\\nassert give_hash(r_installer, hashlib.sha1) == hashes[1]\\n# If you are \\\"USB life style\\\", or multi-winpython\\n# ==> CLICK the OPTION \\\"Don't create a StartMenuFolder' <== (when it will show up)\\n\\n!start cmd \\/C %r_installer% \\/DIR=%tmp_Rbase% %tmp_R_comp%\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"FADL1\\/custom_model.ipynb\\\".\\nThe first task is:\\nHere's code to do cross-validation:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef get_model_i(i=0):\\n val_idxs = get_cv_idxs(n, i, val_pct=0.1)\\n tfms = tfms_from_model(f_model, sz, aug_tfms=transforms_basic, max_zoom=1.05)\\n data = ImageClassifierData.from_csv(path, 'train', f'{path}train.csv', bs, tfms, \\n val_idxs=val_idxs, suffix='.jpg', continuous=True)\\n learn = ConvLearnerVGG.pretrained(data, ps=0.0, precompute=False)\\n return learn\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2.2\\/tutorials\\/general_concepts.ipynb\\\".\\nThe first task is:\\nFloatParameters also have their own method to access an astropy Quantity object that includes both the value and the unit\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(param.get_quantity(), param.get_quantity(unit=u.km))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# First get the weights of the embedding layer\\ne = model.layers[0]\\nweights = e.get_weights()[0]\\nprint(weights.shape) # shape: (vocab_size, embedding_dim)\\n\\nimport io\\n\\n# Create the reverse word index\\nreverse_word_index = dict([(value, key) for (key, value) in word_index.items()])\\n\\n# Write out the embedding vectors and metadata\\nout_v = io.open('vecs.tsv', 'w', encoding='utf-8')\\nout_m = io.open('meta.tsv', 'w', encoding='utf-8')\\nfor word_num in range(1, vocab_size):\\n word = reverse_word_index[word_num]\\n embeddings = weights[word_num]\\n out_m.write(word + \\\"\\\\n\\\")\\n out_v.write('\\\\t'.join([str(x) for x in embeddings]) + \\\"\\\\n\\\")\\nout_v.close()\\nout_m.close()\\n\\n# Download the files\\ntry:\\n from google.colab import files\\nexcept ImportError:\\n pass\\nelse:\\n files.download('vecs.tsv')\\n files.download('meta.tsv')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nGet files for visualizing the network\\nThe code below will download two files for visualizing how your network \\\"sees\\\" the sentiment related to each word. Head to http:\\/\\/projector.tensorflow.org\\/ and load these files, then click the checkbox to \\\"sphereize\\\" the data.\\nNote: You may run into errors with the projection if your vocab_size earlier was larger than the actual number of words in the vocabulary, in which case you'll need to decrease this variable and re-train in order to visualize.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%sql select count(*) from (select distinct(link_dir) from here.ta_201711) nov\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTotal distinct link_dir in Nov:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# tokenise\\ncorpusTokens = [s.split() for s in corpusNoPunct]\\n\\ncorpusTokens[0:3]\\n\\n# Stem document \\nfrom nltk import PorterStemmer\\nporter = PorterStemmer()\\n\\ncorpus = []\\nfor tweet in corpusTokens:\\n cleanTokens = [token for token in tweet if token not in stopWords] # a list of tokens\\n stemmedTokens = [porter.stem(token) for token in cleanTokens]\\n cleanTweet = ' '.join(stemmedTokens)\\n\\n corpus.append(cleanTweet)\\n\\ncorpus[0:5]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTo remove a word from the corpus if that word is contained in our stopwords set, we need first to tokenise the corpus (i.e., split it into words or tokens):\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Currently, all columns are object type. The data will be easier to work with if the types are converted where appropriate\\n\\ntime_local -> datetime\\nupstream_response_time -> float\\nrequest_time -> float\\nbody_bytes_sent -> integer\\n\\nstatus is a numerical code so could be converted to an integer but as this is a categorical variable we probably don't need to convert it\\n\",\"targets\":\"log['time_local'] = pd.to_datetime(log['time_local'].apply(lambda x : x.split(' ')[0]), format='%d\\/%b\\/%Y:%H:%M:%S')\\n\\nlog.loc[log['upstream_response_time'] == '-', 'upstream_response_time'] = np.nan\\nlog[['upstream_response_time', 'request_time']] = log[['upstream_response_time', 'request_time']].astype(np.float64)\\nlog['body_bytes_sent'] = log['body_bytes_sent'].astype(np.int64)\\n\\nlog.info()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Pyjournalists_zika.ipynb\\\".\\nThe first task is:\\n2.4 Concatenate several DataFrames\\nIf we want to have the historical data to see the evolution of the disease we need to create a new DataFrame containing the content of the different csv files. We use pd.concat() to concatenate one DataFrame per csv file.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport glob \\n\\n#glob finds all the pathnames matching a specified pattern\\ncsv_list = glob.glob(\\\"data\\/*.csv\\\")\\n\\ndf_list = []\\nfor f in csv_list:\\n df = pd.read_csv(f)\\n df_list.append(df)\\nyear_df = pd.concat(df_list, ignore_index=True)\\n# NOTE: a more pythonic way of doing the last five lines would be:\\n# year_df = pd.concat((pd.read_csv(f) for f in all_files), ignore_index=True)\\n\\nyear_df.shape\\n\\nyear_df.head(2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"34. Microphysics Precipitation --> Large Scale Precipitation\\nProperties of the large scale precipitation scheme\\n34.1. Scheme Name\\nIs Required: FALSE Type: STRING Cardinality: 0.1\\nCommonly used name of the large scale precipitation parameterisation scheme\\n\",\"targets\":\"# PROPERTY ID - DO NOT EDIT ! \\nDOC.set_id('cmip6.atmos.microphysics_precipitation.large_scale_precipitation.scheme_name') \\n\\n# PROPERTY VALUE: \\n# Set as follows: DOC.set_value(\\\"value\\\") \\nDOC.set_value(\\\"RAS\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2_1-Kontinuumsstroemungen_Einfuehrung.ipynb\\\".\\nThe first task is:\\nRotation eines Vektorfeldes\\nDie Rotation eines Vektorfeldes ist durch das Kreuzprodukt des Nabla-Operators mit dem Vektorfeld definiert:\\n$$\\\\text{rot}~\\\\overrightarrow{v} = \\\\nabla \\\\times \\\\overrightarrow{v} = \\\\begin{pmatrix}\\n\\\\frac{\\\\partial v_z}{\\\\partial y} - \\\\frac{\\\\partial v_y}{\\\\partial z} \\\\\\n\\\\frac{\\\\partial v_x}{\\\\partial z} - \\\\frac{\\\\partial v_z}{\\\\partial x} \\\\\\n\\\\frac{\\\\partial v_y}{\\\\partial x} - \\\\frac{\\\\partial v_x}{\\\\partial y} \\\\\\n\\\\end{pmatrix}$$\\nIn Python gibt es keine vorgefertigte Funktion zur Berechnung der Rotation. Wir basteln uns deshalb selbst eine (hier für 2D):\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef curl2d(x, y, u, v):\\n return ((np.diff(v,axis=1)\\/np.diff(x,axis=1))[:-1,:] \\n - (np.diff(u,axis=0)\\/np.diff(y,axis=0))[:,:-1])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Instead of a single set of initial w's, we create a batch of 8.\\nnum_chains = 8\\ninitial_state = np.zeros([num_chains, num_features + 1])\\n\\nchains, kernel_results = run_chain(initial_state)\\n\\nr_hat = tfp.mcmc.potential_scale_reduction(chains)\\nprint(\\\"Acceptance rate:\\\", kernel_results.inner_results.is_accepted.numpy().mean())\\nprint(\\\"R-hat diagnostic (per latent variable):\\\", r_hat.numpy())\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n診断\\nプロットのトレーシングは悪い方法であありませんが、診断の方が優れています！\\nまず、複数のチェーンを実行する必要があります。これは、initial_state テンソルのバッチを指定するだけで行えます。\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1-2. 変数\\n代入と参照\\n\\n代入：具体的な値を変数に入れること．\\n参照：変数に代入した値を利用すること\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nx = 0.9 # 値を代入\\ny = 1 + 5 # 演算結果を代入\\nprint(x+y)\\n\\nmessage = \\\"Hello\\\" # 文字列も同様\\nprint(message)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2.3\\/tutorials\\/nelder_mead.ipynb\\\".\\nThe first task is:\\nHere, for example, we see that our 'fastcompute' is ignoring the Rossiter-McLaughlin effect. In practice, since we have data in this region, this would be a cause for concern. For this example, our fake data was created using the same 'fastcompute' options... so we won't worry about it.\\nAdopting Solution\\nTo \\\"permananetly\\\" adopt these proposed changes, we call b.adopt_solution (and can optionally pass remove_solution=True to cleanup the solution parameters if they will no longer be needed)\\nCan you write Python code for it?\\n\",\"targets\":\"\\nb.adopt_solution('nm_sol')\\n\\nprint(b.filter(qualifier=['q', 'vgamma', 't0_supconj'], context=['component', 'system']))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# 定义预测函数\\ndef predict(theta, X):\\n probability = sigmoid(X * theta.T)\\n return [1 if x >= 0.5 else 0 for x in probability]\\n\\n# 统计预测正确率\\ntheta_min = np.matrix(result[0])\\npredictions = predict(theta_min, X)\\ncorrect = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y)]\\naccuracy = (sum(map(int, correct)) \\/ len(correct))\\nprint ('accuracy = {0}%'.format(accuracy*100))\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n评价逻辑回归模型\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%script sbcl --noinform --eval \\\"(require 'sb-aclrepl)\\\" --eval \\\"(setq sb-aclrepl:*prompt* \\\\\\\"\\\\\\\")\\\"\\n\\n(setf (symbol-function 'counter)\\n (let ((count 0))\\n (lambda ()\\n (if (> count 5)\\n (setf count 0)\\n (incf count)\\n ) ; if\\n ) ; lambda\\n ) ; let\\n)\\n\\n(counter)\\n(counter)\\n(counter)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nJake’s example of lexical binding in action:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"All of the other read_XXX methods in Pandas work from CAS connection objects and support the same options. See the Pandas documentation for the other data reader methods and options.\\nLet's move on to the next method of loading data: the upload method.\\nLoading Data Using the upload Method\\nThe next way of loading data is by sending a data file to the server using the upload CAS object method. In this style of loading data, the parsing of the file is done on the server-side; the file is simply uploaded as binary data and the table.loadtable action is run in the background. This has the benefit that the parsing can be done with much faster parsers than what can be done in Python. Some parsers can even execute in parallel so the parsing load is split across nodes in the CAS grid. The downside is that there aren't as many parsing options as what the Pandas data readers offer, so both methods still have their place. Let's look at code that uploads data files into CAS tables.\\nWe'll start off with CSV files since they are ubiquitous.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nout = conn.upload('https:\\/\\/raw.githubusercontent.com\\/sassoftware\\/sas-viya-programming\\/master\\/data\\/cars.csv')\\nout\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"12. What time of day do people usually get their tickets? You can break the day up into several blocks - for example 12am-6am, 6am-12pm, 12pm-6pm, 6pm-12am.\\n\",\"targets\":\"def time_to_words(first_two_digits_are_your_hour):\\n if not first_two_digits_are_your_hour:\\n return None\\n elif first_two_digits_are_your_hour.startswith('ERROR'):\\n return None\\n else:\\n try:\\n hour = int(first_two_digits_are_your_hour[:2])\\n if hour < 6:\\n return 'early_morning'\\n elif hour < 12:\\n return 'morning'\\n elif hour < 18:\\n return 'afternoon'\\n elif hour < 24:\\n return 'evening'\\n else:\\n return 'ERROR'\\n except:\\n return 'ERROR'\\n\\ndf_merged['Violation Time in Words'] = df_merged['Violation Time Formatted'].apply(time_to_words)\\n\\ndf_merged['Violation Time in Words'].value_counts()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Author: Denis Engemann \\n#\\n# License: BSD (3-clause)\\n\\nimport mne\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nfrom mne.datasets import sample\\n\\nprint(__doc__)\\n\\ndata_path = sample.data_path()\\nraw_fname = data_path + '\\/MEG\\/sample\\/sample_audvis_filt-0-40_raw.fif'\\nevent_fname = data_path + '\\/MEG\\/sample\\/sample_audvis_filt-0-40_raw-eve.fif'\\n\\n# These data already have an average EEG ref applied\\nraw = mne.io.read_raw_fif(raw_fname)\\n\\n# For simplicity we will only consider the first 10 epochs\\nevents = mne.read_events(event_fname)[:10]\\n\\n# Add a bad channel\\nraw.info['bads'] += ['MEG 2443']\\npicks = mne.pick_types(raw.info, meg='grad', eeg=True, eog=True,\\n stim=False, exclude='bads')\\n\\ntmin, tmax = -0.2, 0.5\\nbaseline = (None, 0)\\nreject = dict(grad=4000e-13, eog=150e-6)\\n\\nevent_id = dict(auditory_l=1, auditory_r=2, visual_l=3, visual_r=4)\\n\\nepochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks,\\n baseline=baseline, preload=True, reject=reject)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExport epochs to Pandas DataFrame\\nIn this example the pandas exporter will be used to produce a DataFrame\\nobject. After exploring some basic features a split-apply-combine\\nwork flow will be conducted to examine the latencies of the response\\nmaxima across epochs and conditions.\\nNote<\\/h4>Equivalent methods are available for raw and evoked data objects.<\\/p><\\/div>\\n\\nMore information and additional introductory materials can be found at the\\npandas doc sites: http:\\/\\/pandas.pydata.org\\/pandas-docs\\/stable\\/\\nShort Pandas Primer\\nPandas Data Frames\\n~~~~~~~~~~~~~~~~~~\\nA data frame can be thought of as a combination of matrix, list and dict:\\nIt knows about linear algebra and element-wise operations but is size mutable\\nand allows for labeled access to its data. In addition, the pandas data frame\\nclass provides many useful methods for restructuring, reshaping and visualizing\\ndata. As most methods return data frame instances, operations can be chained\\nwith ease; this allows to write efficient one-liners. Technically a DataFrame\\ncan be seen as a high-level container for numpy arrays and hence switching\\nback and forth between numpy arrays and DataFrames is very easy.\\nTaken together, these features qualify data frames for inter operation with\\ndatabases and for interactive data exploration \\/ analysis.\\nAdditionally, pandas interfaces with the R statistical computing language that\\ncovers a huge amount of statistical functionality.\\nExport Options\\n~~~~~~~~~~~~~~\\nThe pandas exporter comes with a few options worth being commented.\\nPandas DataFrame objects use a so called hierarchical index. This can be\\nthought of as an array of unique tuples, in our case, representing the higher\\ndimensional MEG data in a 2D data table. The column names are the channel names\\nfrom the epoch object. The channels can be accessed like entries of a\\ndictionary::\\n>>> df['MEG 2333']\\n\\nEpochs and time slices can be accessed with the .loc method::\\n>>> epochs_df.loc[(1, 2), 'MEG 2333']\\n\\nHowever, it is also...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1. Single-subject dataset example\\nGetting started\\nWe will use a dataset where one subject was presented with 92 different visual stimuli while brain responses were measured in 100 voxels.\\nThe different visual stimuli (each row) are the conditions, and the voxels (each column) are the measurement channels.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# import the measurements for the dataset\\nmeasurements = io.matlab.loadmat('92imageData\\/simTruePatterns.mat')\\nmeasurements = measurements['simTruePatterns']\\nnCond = measurements.shape[0]\\nnVox = measurements.shape[1]\\n\\n# plot the imported data\\nplt.imshow(measurements,cmap='gray') \\nplt.xlabel('Voxels')\\nplt.ylabel('Conditions')\\nplt.title('Measurements')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Caching transformers within a Pipeline\\n\\nIt is sometimes worthwhile storing the state of a specific transformer\\n since it could be used again. Using a pipeline in GridSearchCV triggers\\n such situations. Therefore, we use the argument memory to enable caching.\\n.. warning::\\n Note that this example is, however, only an illustration since for this\\n specific case fitting PCA is not necessarily slower than loading the\\n cache. Hence, use the memory constructor parameter when the fitting\\n of a transformer is costly.\\n\",\"targets\":\"from tempfile import mkdtemp\\nfrom shutil import rmtree\\nfrom sklearn.externals.joblib import Memory\\n\\n# Create a temporary folder to store the transformers of the pipeline\\ncachedir = mkdtemp()\\nmemory = Memory(cachedir=cachedir, verbose=10)\\ncached_pipe = Pipeline([('reduce_dim', PCA()),\\n ('classify', LinearSVC())],\\n memory=memory)\\n\\n# This time, a cached pipeline will be used within the grid search\\ngrid = GridSearchCV(cached_pipe, cv=3, n_jobs=1, param_grid=param_grid)\\ndigits = load_digits()\\ngrid.fit(digits.data, digits.target)\\n\\n# Delete the temporary cache before exiting\\nrmtree(cachedir)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Creating lattice\\nOcelot has following elements: Drift, Quadrupole, Sextupole, Octupole, Bend, SBend, RBend, Edge, Multipole, Hcor, Vcor, Solenoid, Cavity, Monitor, Marker, Undulator.\\n\",\"targets\":\"# defining of the drifts\\nD1 = Drift(l=2.)\\nD2 = Drift(l=0.6)\\nD3 = Drift(l=0.3)\\nD4 = Drift(l=0.7)\\nD5 = Drift(l=0.9)\\nD6 = Drift(l=0.2)\\n\\n# defining of the quads\\nQ1 = Quadrupole(l=0.4, k1=-1.3)\\nQ2 = Quadrupole(l=0.8, k1=1.4)\\nQ3 = Quadrupole(l=0.4, k1=-1.7)\\nQ4 = Quadrupole(l=0.5, k1=1.3)\\n\\n# defining of the bending magnet\\nB = Bend(l=2.7, k1=-.06, angle=2*pi\\/16., e1=pi\\/16., e2=pi\\/16.)\\n\\n# defining of the sextupoles\\nSF = Sextupole(l=0.01, k2=1.5) #random value\\nSD = Sextupole(l=0.01, k2=-1.5) #random value\\n\\n# cell creating\\ncell = (D1, Q1, D2, Q2, D3, Q3, D4, B, D5, SD, D5, SF, D6, Q4, D6,\\n SF, D5, SD, D5, B, D4, Q3, D3, Q2, D2, Q1, D1)\\n\\ncell\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3. 搜索\\nNumPy有多个函数可以在数据中进行搜索。\\n\\nargmax函数返回数组中最大值对应的下标\\n\",\"targets\":\"a = np.array([2,4,8])\\nnp.argmax(a)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# prepare digits to send to online prediction endpoint\\ndigits_float32 = np.concatenate((font_digits, validation_digits[:100-N])) # pixel values in [0.0, 1.0] float range\\ndigits_uint8 = np.round(digits_float32*255).astype(np.uint8) # pixel values in [0, 255] int range\\nlabels = np.concatenate((font_labels, validation_labels[:100-N]))\\nwith open(\\\"digits.json\\\", \\\"w\\\") as f:\\n for digit in digits_uint8:\\n # the format for AI Platform online predictions is: one JSON object per line\\n data = json.dumps({\\\"images\\\": digit.tolist()}) # \\\"images\\\" because that was the name you gave this parametr in the serving funtion my_serve\\n f.write(data+'\\\\n')\\n\\n# Request online predictions from deployed model (REST API) using the \\\"gcloud ml-engine\\\" command line.\\npredictions = !gcloud ai-platform predict --model={MODEL_NAME} --json-instances digits.json --project={PROJECT} --version {MODEL_VERSION}\\nprint(predictions)\\n\\npredictions = np.stack([json.loads(p) for p in predictions[2:]]) # first elemet is the name of the output layer: drop it, parse the rest\\ndisplay_top_unrecognized(digits_float32, predictions, labels, N, 100\\/\\/N)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTest the deployed model\\nYour model is now available as a REST API. Let us try to call it. The cells below use the \\\"gcloud ml-engine\\\"\\ncommand line tool but any tool that can send a JSON payload to a REST endpoint will work.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%matplotlib inline\\nfrom matplotlib import pyplot as plt\\nfrom pandas import DataFrame\\n\\ndef plot_by(df, column='Dept Name', count=10, ascending=False):\\n \\n # Group the data by the column specified and sum the totals.\\n data = df.groupby(column)['Total'].sum().dropna()\\n \\n # Sort the data.\\n data = DataFrame(data, columns=['Total']).sort('Total', ascending=ascending)\\n \\n # Plot the subset of the sorted data that the user is interested in.\\n data = data[:count].plot(kind='bar')\\n \\n # Plot settings.\\n plt.title('%s Costs' % column)\\n plt.ylabel('Cost ($)')\\n\\nfrom IPython.html.widgets import interact, fixed\\ninteract(plot_by, df=fixed(df), column=df.columns.tolist(), count=(5,15));\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow the data can be explored using matplotlib and interact. The following function plots the costs of the selected parameter type.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"MNIST_NP_Softmax_Basic.ipynb\\\".\\nThe first task is:\\nThe Accuracy function takes two vectors of class labels and computes the accuracy or in other words how many of them match.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef Accuracy(preds, labels):\\n accuracy = sum(preds == labels)\\/(float(len(labels)))\\n return accuracy\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Comment the cases for which the p-value is very low (i.e. p < 0.01).\\nPart c\\n$$\\\\int {-1}^1\\\\int {-1}^1e^{-6 x^2+10 x y-6 y^2}dxdy=0.86787$$\\n2d midpoint integration\\n\\n\\n\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Definition of the T values for which to calculate alpha and beta\\nN = 100\\nrvec = np.linspace(1e-6,np.sqrt(2),N)\\n# initializate arrays for each method\\nalpha_int_r = np.empty(N)\\nbeta_int_r = np.empty(N)\\nalpha_hist_r = np.empty(N)\\nbeta_hist_r = np.empty(N)\\n\\n# midpoint parameters\\nTint_r = np.sqrt(Xint**2+Yint**2)\\n\\n# histogram quadrature parameters\\nNb_r = 100\\nT_bins_r = np.linspace(0, np.sqrt(2),Nb_r+1)\\ntstShist_r, tstShist_edges = np.histogram(tstSR,bins=T_bins_r,normed=1)\\ntstBhist_r, tstBhist_edges = np.histogram(tstBR,bins=T_bins_r,normed=1)\\nbin_width_r = tstShist_edges[1]-tstShist_edges[0]\\n\\nfor i,Tcut in enumerate(rvec):\\n alpha_int_r[i], beta_int_r[i] = test_int(Tcut,tstSR,tstBR)\\n alpha_hist_r[i], beta_hist_r[i] = hist_integral(Tcut,tstShist_r,tstBhist_r,T_bins_r)\\n\\nstn_int_r = (1-alpha_int_r)\\/np.sqrt(beta_int_r)\\nstn_hist_r = (1-alpha_hist_r)\\/np.sqrt(beta_hist_r)\\n\\nfigs = [plt.figure(j+1) for j in range(3)]\\nax1, ax2, ax3 = [fig.add_subplot(111) for fig in figs]\\nax1.plot(rvec,1-alpha_int_r,'--',lw=3,label='int')\\nax1.plot(rvec,1-alpha_hist_r,':',lw=3,label='histogram')\\nax1.set_ylabel(r'$1-\\\\alpha$')\\nax2.plot(rvec,beta_int_r,'--',lw=3,label='int')\\nax2.plot(rvec,beta_hist_r,':',lw=3,label='histogram')\\nax2.set_ylabel(r'$\\\\beta$')\\nax3.plot(rvec,stn_int_r,'--',lw=3,label='int')\\nax3.plot(rvec[1:],stn_hist_r[1:],':',lw=3,label='histogram')\\nax3.set_ylabel(r'$\\\\frac{1-\\\\alpha}{\\\\sqrt{\\\\beta}}$')\\nfor ax in [ax1,ax2,ax3]:\\n ax.set_xlabel('r')\\n ax.grid(True)\\n ax.legend()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Feature Selector Usage.ipynb\\\".\\nThe first task is:\\nWe can view a heatmap of the correlations above the threhold. The features which will be dropped are on the x-axis.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfs.plot_collinear()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"4. Enter DV360 Segmentology Parameters\\nDV360 funnel analysis using Census data.\\n 1. Wait for BigQuery->->->Census_Join<\\/b> to be created.\\n 1. Join the StarThinker Assets Group<\\/a> to access the following assets\\n 1. Copy DV360 Segmentology Sample<\\/a>. Leave the Data Source as is, you will change it in the next step.\\n 1. Click Edit Connection, and change to BigQuery->->->Census_Join<\\/b>.\\n 1. Or give these intructions to the client.\\nModify the values below for your use case, can be done multiple times, then click play.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nFIELDS = {\\n 'auth_read': 'user', # Credentials used for reading data.\\n 'recipe_timezone': 'America\\/Los_Angeles', # Timezone for report dates.\\n 'recipe_project': '', # Project ID hosting dataset.\\n 'auth_write': 'service', # Authorization used for writing data.\\n 'recipe_name': '', # Name of report, not needed if ID used.\\n 'recipe_slug': '', # Name of Google BigQuery dataset to create.\\n 'partners': [], # DV360 partner id.\\n 'advertisers': [], # Comma delimited list of DV360 advertiser ids.\\n}\\n\\nprint(\\\"Parameters Set To: %s\\\" % FIELDS)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Check the columns\\nFR_re_df.isnull().all()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCheck missing values\\nNow, we will drop all the columns and all the rows which contain only null values.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3. ANOVA tables and post-hoc comparisons\\n Note<\\/h4>ANOVAs and post-hoc tests are only available for :code:`Lmer` models estimated using the :code:`factors` argument of :code:`model.fit()` and rely on implementations in R<\\/p><\\/div>\\n\\nIn the previous tutorial where we looked at categorical predictors, behind the scenes :code:pymer4 was using the :code:factor functionality in R. This means the output of :code:model.fit() looks a lot like :code:summary() in R applied to a model with categorical predictors. But what if we want to compute an F-test across all levels of our categorical predictor?\\n:code:pymer4 makes this easy to do, and makes it easy to ensure Type III sums of squares infereces are valid. It also makes it easy to follow up omnibus tests with post-hoc pairwise comparisons.\\nANOVA tables and orthogonal contrasts\\nBecause ANOVA is just regression, :code:pymer4 can estimate ANOVA tables with F-results using the :code:.anova() method on a fitted model. This will compute a Type-III SS table given the coding scheme provided when the model was initially fit. Based on the distribution of data across factor levels and the specific coding-scheme used, this may produce invalid Type-III SS computations. For this reason the :code:.anova() method has a :code:force-orthogonal=True argument that will reparameterize and refit the model using orthogonal polynomial contrasts prior to computing an ANOVA table.\\nHere we first estimate a mode with dummy-coded categories and suppress the summary output of :code:.fit(). Then we use :code:.anova() to examine the F-test results.\\n\",\"targets\":\"# import basic libraries and sample data\\nimport os\\nimport pandas as pd\\nfrom pymer4.utils import get_resource_path\\nfrom pymer4.models import Lmer\\n\\n# IV3 is a categorical predictors with 3 levels in the sample data\\ndf = pd.read_csv(os.path.join(get_resource_path(), \\\"sample_data.csv\\\"))\\n\\n# # We're going to fit a multi-level regression using the\\n# categorical predictor (IV3) which has 3 levels\\nmodel = Lmer(\\\"DV ~ IV3 + (1|Group)\\\", data=df)\\n\\n# Using dummy-coding; suppress summary output\\nmodel.fit(factors={\\\"IV3\\\": [\\\"1.0\\\", \\\"0.5\\\", \\\"1.5\\\"]}, summarize=False)\\n\\n# Get ANOVA table\\nprint(model.anova())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Part1a_Fundamentals_of_Programming.ipynb\\\".\\nThe first task is:\\nSets\\nInstances of the set type are equivalent to mathematical sets. Like their math counterparts, literal sets in Python are defined by comma seperated values between curly braces ({}). Sets are unordered containers of unique values. Duplicated elements are ignored. Beacuse they unordered, sets are not sequences and cannot be duplicated.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# a literal set formed with elements of various types\\n{1.0, 10, \\\"one hundred\\\", (1, 0, 0, 0)}\\n\\n# a literal set OF special values\\n{True, False, None, \\\"\\\", 0.0, 0}\\n\\n# conversion from a list to a set\\nset([2.0, 4, \\\"eight\\\", (16,), 4, 4, 2.0])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%matplotlib inline\\nimport matplotlib.pyplot as plt\\nfrom mpl_toolkits.mplot3d import Axes3D\\nplt.xkcd()\\nfig = plt.figure(figsize=(10, 5))\\nax = fig.add_subplot(121, projection='3d')\\nax.plot_surface(x, y, f)\\nax.set_title('Original function')\\nax = fig.add_subplot(122, projection='3d')\\nax.plot_surface(x, y, fappr - f)\\nax.set_title('Approximation error with rank=%d, err=%3.1e' % (r, er))\\nfig.subplots_adjust()\\nfig.tight_layout()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAnd do some 3D plotting\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create Convolutional Model\\nImplement the function conv_net to create a convolutional neural network model. The function takes in a batch of images, x, and outputs logits. Use the layers you created above to create this model:\\n\\nApply 1, 2, or 3 Convolution and Max Pool layers\\nApply a Flatten Layer\\nApply 1, 2, or 3 Fully Connected Layers\\nApply an Output Layer\\nReturn the output\\nApply TensorFlow's Dropout to one or more layers in the model using keep_prob.\\n\",\"targets\":\"def conv_net(x, keep_prob):\\n \\\"\\\"\\\"\\n Create a convolutional neural network model\\n : x: Placeholder tensor that holds image data.\\n : keep_prob: Placeholder tensor that hold dropout keep probability.\\n : return: Tensor that represents logits\\n \\\"\\\"\\\"\\n # Should I attempt the Siraj's VGG16 conv model? xxx given we have merged conv2d and max into \\n # a single function, I guess below is not possible the way this project is setup. Another day.\\n # Conv block 1 with 064 output filters - Conv2d > Conv2d > MaxPooling2D\\n # Conv block 2 with 128 output filters - Conv2d > Conv2d > MaxPooling2D\\n # Conv block 3 with 256 output filters - Conv2d > Conv2d > Conv2d > MaxPooling2d\\n # Conv block 4 with 512 output filters - Conv2d > Conv2d > Conv2d > MaxPooling2d\\n # Fully-connected classifier - Flatten > Dense > Dense > Dense\\n '''\\n model_vgg = Sequential()\\n model_vgg.add(ZeroPadding2D((1, 1), input_shape=(img_width, img_height,3)))\\n model_vgg.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_1'))\\n model_vgg.add(ZeroPadding2D((1, 1)))\\n model_vgg.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_2'))\\n model_vgg.add(MaxPooling2D((2, 2), strides=(2, 2)))\\n\\n model_vgg.add(ZeroPadding2D((1, 1)))\\n model_vgg.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_1'))\\n model_vgg.add(ZeroPadding2D((1, 1)))\\n model_vgg.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_2'))\\n model_vgg.add(MaxPooling2D((2, 2), strides=(2, 2)))\\n\\n model_vgg.add(ZeroPadding2D((1, 1)))\\n model_vgg.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_1'))\\n model_vgg.add(ZeroPadding2D((1, 1)))\\n model_vgg.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_2'))\\n model_vgg.add(ZeroPadding2D((1, 1)))\\n model_vgg.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_3'))\\n model_vgg.add(MaxPooling2D((2, 2), strides=(2, 2)))\\n\\n model_vgg.add(ZeroPadding2D((1, 1)))\\n model_vgg.add(Convolution2D(512, 3, 3, activation='relu',...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2.3 Question 3\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nliste1 = [\\\"a\\\", \\\"b\\\", \\\"c\\\", \\\"d\\\", \\\"e\\\"]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Configure and build the neural network.\\nEach layer has the 4 inputs $\\\\mathbf{H}^{T}\\\\mathbf{r}$, $\\\\mathbf{H}^{T}\\\\mathbf{H}$, $\\\\mathbf{t}_k$ and $\\\\mathbf{v}_k$. The index $k$ denotes the layer. The layers can also be interpreted as iterations of an optimization algorithm [1].\\nThe nonlinear operation\\n$\\n\\\\begin{align}\\n&\\\\quad z_{k} = \\\\rho\\\\left(\\\\text{W}{1k}\\\\begin{bmatrix}\\n\\\\mathbf{H}^{T}\\\\mathbf{r}\\\\\\n\\\\hat{\\\\mathbf{t}}{k}\\\\\\n\\\\mathbf{H}^{T}\\\\mathbf{H}\\\\hat{\\\\text{t}}{k}\\\\\\n\\\\mathbf{v}{k}\\n\\\\end{bmatrix}+\\\\mathbf{b}{1k}\\\\right)\\\\\\n&\\\\hat{\\\\mathbf{t}}{k+1} = \\\\psi_{t_{k}}(\\\\mathbf{W}{2k}\\\\mathbf{z}{k}+\\\\mathbf{b}{2k})\\\\\\n&\\\\hat{\\\\mathbf{v}}{k+1} = \\\\mathbf{W}{3k}\\\\mathbf{z}{k}+\\\\mathbf{b}{3k}\\\\\\n&\\\\qquad\\\\hat{\\\\mathbf{t}}{1} = \\\\mathbf{0}\\\\tag{10}\\n\\\\end{align}\\n$\\nis applied to the input. $\\\\mathbf{t}_0$ is the received data vector.\\nSummarized, each layer does roughly the following steps:\\n* Concatenate the inputs.\\n* Linear transformation.\\n* Apply ReLU function.\\n* Calculate $\\\\mathbf{v}{k+1}$ as a linear trafo of the ReLU output and use ResNet feature.\\n* Calculate $\\\\hat{\\\\mathbf{t}}{k+1}$ as a linear trafo of the ReLU output which is then fed to the linear soft sign function.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# DetNet config\\nlayers = 3*K\\nv_len = 2*K\\nz_len = 8*K\\n\\n# Training params\\ntraining_steps = 10000\\nbatch_size_train = 5000\\nsnr_var_train = 3.0 # Maximum absolute deviation of the SNR from its mean in logarithmic scale.\\n\\n# Test params\\ntest_steps= 1000\\nbatch_size_test = 5000\\nsnr_range = np.arange(8, 14, 1)\\n\\n# Definition of the Loss function\\ndef own_loss(t, t_train, t_ZF):\\n loss_l = torch.zeros(len(t), 1, device=device) # Denotes the loss in Layer L\\n for layer in range(1,len(t)+1):\\n loss_l[layer-1] = torch.log(torch.Tensor([layer+1]).to(device))*torch.mean(torch.mean(torch.square(t_train - t[layer-1]),1)\\/torch.mean(torch.square(t_train - t_ZF),1))\\n return loss_l\\n \\n\\n# Definition of the DetNet\\nclass DetNet(nn.Module):\\n # Build DetNet\\n def __init__(self, layers, K, v_len, z_len):\\n # Here we define the trainable parameter (Net)\\n super(DetNet, self).__init__()\\n # We have to use here nn.ModuleList instead of a PythonList. (Otherwise you’ll get an error saying\\n # that your model has no parameters, because PyTorch does not see the parameters of the layers stored\\n # in a Python list)\\n # Furtheremore, we initialize the linear trafo with normailzed weights\\n # Linear Traffos W_1l, W_2l, W_3l\\n self.linear_trafo_1_l = nn.ModuleList()\\n self.linear_trafo_1_l.extend([nn.Linear(3*K + v_len, z_len) for i in range(1, layers+1)])\\n for i in range(0, layers):\\n nn.init.normal_(self.linear_trafo_1_l[i].weight, std = 0.01)\\n nn.init.normal_(self.linear_trafo_1_l[i].bias, std = 0.01)\\n self.linear_trafo_2_l = nn.ModuleList()\\n self.linear_trafo_2_l.extend([nn.Linear(z_len, K) for i in range(1, layers+1)])\\n for i in range(0, layers):\\n nn.init.normal_(self.linear_trafo_2_l[i].weight, std = 0.01)\\n nn.init.normal_(self.linear_trafo_2_l[i].bias, std = 0.01)\\n self.linear_trafo_3_l = nn.ModuleList()\\n self.linear_trafo_3_l.extend([nn.Linear(z_len , v_len) for i in range(1,...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"T\\\".istitle()\\n\\n\\\"t\\\".istitle()\\n\\n# we need a list to store the tagged tokens\\ntagged_tokens = []\\n\\n# tokenisation is done by using the string method `split(\\\" \\\")` \\n# that splits a string upon white spaces\\nfor n, token in enumerate(de_bello_gallico_book1.split(\\\" \\\")):\\n if(token.istitle()):\\n tagged_tokens.append((token, \\\"Entity\\\"))\\n else:\\n tagged_tokens.append((token, \\\"O\\\")) \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nVery simple baseline\\nNow let's write what in NLP jargon is called a baseline, that is a method for extracting named entities that can serve as a term of comparison to evaluate the accuracy of other methods. \\nBaseline method: \\n- cycle through each token of the text\\n- if the token starts with a capital letter it's a named entity (only one type, i.e. Entity)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Tehdään luokittelija\\nclf_dt = DecisionTreeClassifier()\\nclf_dt.fit(X_train.reshape(-1,28*28), y_train)\\npred_dt = clf_dt.predict(X_test.reshape(-1,28*28))\\n\\n# Piirretään tulokseksi alkupäästä luokituksia\\npltsize=1\\nplt.figure(figsize=(10*pltsize, pltsize))\\nfor i in range(10):\\n plt.subplot(1,10,i+1)\\n plt.axis('off')\\n plt.imshow(X_test[i,:,:])\\n plt.title(str(pred_dt[i]) + ' (' + str(y_test[i]) + ')')\\n\\n# Raportoidaan tulokset\\nprint('Luokiteltu', len(pred_dt), 'kuvaa, luokituksista oikein menneiden osuus on:', accuracy_score(y_test, pred_dt)*100, '%')\\nprint('Alla kuvat ja analysoidut luokat, oikeat luokat ovat suluissa')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nVoidaanko sanoa, että tämä satunnainen sotku on selvästi eri tulos kuin aiemmin tekemämme pääkomponenttianalyysin tuottama?\\nMerkkien tunnistaminen\\nSeuraavaksi pääsemme itse asiaan. Olemme nyt pöyhineet dataa ja päässeet varmuuteen, että se on järkevää ja analysoitavissa.\\nRakennamme koneoppimismenetelmiä käyttäen nk. luokittelijan, joka kykenee oppimaan kuvien piirteet ja tunnistamaan niitä sen jälkeen. Nyt on syytä jälleen olla tarkkana: jos syötämme menetelmälle dataa, niin se varmasti osaa oppia ulkoa kyseisen datan kaikki yksityiskohdat. Mutta haluamme, että menetelmä \\\"näkee metsän puilta\\\", eli oppii tunnistamaan merkkien yleisiä hahmoja. Teemme siis koneoppimisen perustempun, eli jaamme datan kahteen osaan. Harjoitusdatalla opetetaan menetelmä, kun taas sen toimintaa testataan testidatalla. Koneoppijan tulee siis selvitä sellaisistakin kuvista, joita se ei ole aikaisemmin nähnyt. Tällä tavalla varmistetaan, että ei pelkästään opita ulkoa harjoitusdataa.\\nAlla oleva koodi tekee luokittelun ja tulostaa esimerkiksi 10 ensimmäistä luokiteltua merkkiä. Luokitteluun käytetään klassista koneoppimisen menetelmää, nk. päätöspuuta. Kuinka hyvin menetelmä pärjää?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Com maior refinamento de dados:\\nMultinomialNB:\\nTodos: 0.808652246256\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.ensemble import AdaBoostClassifier\\nclassificador = AdaBoostClassifier(n_estimators=100)\\n\\nresultado = fit_and_predict(classificador, treino_dados, treino_marcacoes, teste_dados, teste_marcacoes)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"DL0110EN\\/1.1_1Dtensors_v2.ipynb\\\".\\nThe first task is:\\nThe result is simply tensor([3, 4])<\\/code>. This result is achieved by multiplying every element in u<\\/code> with the corresponding element in the same position v<\\/code>, which is similar to [1 * 3, 2 * 2]<\\/i>.\\n\\n\\nDot Product<\\/h3>\\n\\nThe dot product is a special operation for a vector that you can use in Torch.\\nHere is the dot product of the two tensors u<\\/code> and v<\\/code>:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Calculate dot product of u, v\\n\\nu = torch.tensor([1, 2])\\nv = torch.tensor([3, 2])\\n\\nprint(\\\"Dot Product of u, v:\\\", torch.dot(u,v))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%Table members\\nMEMBERID,NODEJ,NODEK\\nAB,A,B\\nBC,B,C\\nDC,D,C\\n\\n@sl.extend(Frame2D)\\nclass Frame2D:\\n \\n COLUMNS_members = ('MEMBERID','NODEJ','NODEK')\\n \\n def install_members(self):\\n table = self.get_table('members')\\n for ix,m in table.data.iterrows():\\n if m.MEMBERID in self.members:\\n raise Exception('Multiply defined member: {}'.format(m.MEMBERID))\\n memb = Member(m.MEMBERID,self.get_node(m.NODEJ),self.get_node(m.NODEK))\\n self.members[memb.id] = memb\\n self.rawdata.members = table\\n \\n def get_member(self,id):\\n try:\\n return self.members[id]\\n except KeyError:\\n raise Exception('Member not defined: {}'.format(id))\\n\\n##test:\\nf.install_members()\\nf.members\\n\\n##test:\\nm = f.get_member('BC')\\nm.id, m.L, m.dcx, m.dcy\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nMembers\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"1. Загрузите выборку Wine\\n\",\"targets\":\"df = pd.read_csv('..\\/data\\/wine.data')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Data Loading and Management\\n\\nDefine a function to load data \\nConstruct the Bunch object for the data set by defining the paths and file names \\nLoad the features and labels from the meta data \\nLoad the read me description\\nUse Pandas to load data from the txt file\\nExtract the target from the data by indexing with column names\\nCreate a 'Bunch' object, which is a dictionary that exposes dictionary keys as properties so that you can access them with dot notation.\\n\",\"targets\":\"def load_data(root=DATA_DIR):\\n # Construct the `Bunch` for the fertility dataset\\n filenames = {\\n 'meta': os.path.join(root, 'meta.json'),\\n 'rdme': os.path.join(root, 'README.md'),\\n 'data': os.path.join(root, 'fertility_diagnosis.txt'),\\n }\\n\\n # Load the meta data from the meta json\\n with open(filenames['meta'], 'r') as f:\\n meta = json.load(f)\\n target_names = meta['target_names']\\n feature_names = meta['feature_names']\\n\\n # Load the description from the README. \\n with open(filenames['rdme'], 'r') as f:\\n DESCR = f.read()\\n\\n # Load the dataset from the text file.\\n dataset = pd.read_csv('fertility_Diagnosis.txt', delimiter=',', names=FEATURES)\\n \\n # 'diagnosis' is stored as a text value. We convert (or 'map') it into numeric binaries \\n # so it will be ready for scikit-learn.\\n dataset.diagnosis = dataset.diagnosis.map({'N': 0,'O': 1})\\n \\n # Extract the target from the data\\n data = dataset[['season_of_analysis', 'age', 'childhood_disease', 'accident_or_trauma', 'surgical_intervention',\\n 'high_fevers', 'alcohol', 'smoking', 'hours_sitting']]\\n target = dataset['diagnosis']\\n\\n # Create the bunch object\\n return Bunch(\\n data=data,\\n target=target,\\n filenames=filenames,\\n target_names=target_names,\\n feature_names=feature_names,\\n DESCR=DESCR\\n )\\n\\n# Save the dataset as a variable we can use.\\ndataset = load_data()\\n\\nprint(dataset.data.shape)\\nprint(dataset.target.shape)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\".ipynb_checkpoints\\/6. Community Detection-checkpoint.ipynb\\\".\\nThe first task is:\\nFinding Communities\\nTo perform the community detection algorithm, the directed graph needs to be made into an undirected one.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nPR = P.to_undirected()\\nPR = nx.Graph(PR)\\n\\nmypalette = [\\\"blue\\\",\\\"red\\\",\\\"green\\\", \\\"yellow\\\", \\\"orange\\\", \\\"violet\\\", \\\"grey\\\", \\\"grey\\\",\\\"grey\\\"]\\n\\npos = nx.spring_layout(PR)\\n#colors = [mypalette[PR.node[i]['value']] for i in range(1,len(PR.nodes()))]\\ncolors = [mypalette[PR.node[i]['value']] for i in PR.nodes()]\\nnx.draw(PR, pos, node_color=colors, node_size=10)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Python Quick Reference\\/Strings.ipynb\\\".\\nThe first task is:\\nCase insensitive search with reg exps\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntext = 'UPPER PYTHON, lower python, Mixed Python'\\nre.findall('python', text, flags=re.IGNORECASE)\\n\\n# note that case is not carriedd through in a case insensitive replace.\\nre.sub('python', 'snake', text, flags=re.IGNORECASE)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"434\\\" in embeddings\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nDigit Expansion\\nWe reduce the size of the vocabulary while training the embeddings by grouping special classes of words.\\nOnce common case of such grouping is digits.\\nEvery digit in the training corpus get replaced by the symbol #.\\nFor example, a number like 123.54 becomes ###.##.\\nTherefore, querying the embedding for a new number like 434 will result in a failure\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Associer un caractère avec son point de code de façon biunivoque.\\n\",\"targets\":\"def code_cesar(mot='Bonjour tout le monde', decalage=3):\\n \\\"\\\"\\\"César avec un décallage de 1\\\"\\\"\\\"\\n return \\\"\\\".join([chr(ord(c)+decalage) for c in mot])\\ncode_cesar()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Mining massive datasets\\/association.ipynb\\\".\\nThe first task is:\\nPrune non frequent candidate triples\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfor candidate in allCandidateTriples:\\n whatAboutIt = True\\n for pair in itertools.combinations(candidate,2):\\n if pair not in frequentPairs:\\n whatAboutIt = False\\n break\\n if whatAboutIt:\\n candidateTriples[candidate] = 0\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Advanced\\/optional solution:\\n\",\"targets\":\"# %load _solutions\\/case3_bacterial_resistance_lab_experiment6.py\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Level_03\\/Level_3.ipynb\\\".\\nThe first task is:\\nbreak, continue und else\\nDie Schlüsselwörter break, continue und else können wir innerhalb einer for-Schleife genauso benutzen, wie in einer while-Schleife.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nzauberwort = \\\"abracadabra#test\\\"\\nneuer_zauber = \\\"\\\"\\nfor zeichen in zauberwort:\\n if zeichen == \\\"#\\\":\\n break\\n elif zeichen == \\\"a\\\":\\n continue\\n else:\\n neuer_zauber += zeichen\\nprint(neuer_zauber)\\n\\nstring = \\\"Das ist ein Teststring.\\\"\\nfor zeichen in string:\\n if zeichen == \\\"Y\\\":\\n break\\nelse:\\n print(\\\"Kein 'Y' gefunden.\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Set the number of Trotter steps.\\ntrotter_steps = 10\\n\\n# Evolution under the hopping Hamiltonian for a single Trotter step.\\numat = expm(-1j * hopping_matrix * (e_time \\/ trotter_steps))\\n\\n# Simulate each Trotter step.\\ncurrent_wfn = copy.deepcopy(init_wfn)\\nfor _ in range(trotter_steps):\\n # Evolve the Hopping Hamiltonian.\\n current_wfn = evolve_fqe_givens(current_wfn, u=umat)\\n\\n # Evolve the charge-charge interaction.\\n current_wfn = evolve_fqe_charge_charge_alpha_beta(\\n current_wfn, \\n charge_charge_matrix, \\n e_time \\/ trotter_steps,\\n )\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAt this point we can simulate a specified number of Trotter steps as follows.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"1 - Baseline model: Emojifier-V1\\n1.1 - Dataset EMOJISET\\nLet's start by building a simple baseline classifier. \\nYou have a tiny dataset (X, Y) where:\\n- X contains 127 sentences (strings)\\n- Y contains a integer label between 0 and 4 corresponding to an emoji for each sentence\\n\\n Figure 1: EMOJISET - a classification problem with 5 classes. A few examples of sentences are given here. <\\/center><\\/caption>\\nLet's load the dataset using the code below. We split the dataset between training (127 examples) and testing (56 examples).\\n\",\"targets\":\"X_train, Y_train = read_csv('data\\/train_emoji.csv')\\nX_test, Y_test = read_csv('data\\/tesss.csv')\\n\\nmaxLen = len(max(X_train, key=len).split())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"8.Prüfe mit einer Funktionen, wieviele Grossbuchstaben in folgendem Satz zu finden sind.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsatz = \\\"In Oesterreich zeichnet sich ein Rechtsrutsch ab. OeVP und FPOe haben stark zugelegt. Gemaess der neusten Hochrechnung ist die Partei von Sebastian Kurz mit 31,6 Prozent der Stimmen Wahlsiegerin, auf Platz zwei folgt die SPÖ (26,9 Prozent) vor der FPOe (26,0 Prozent).\\\"\\n\\ndef counting_caps(satz):\\n counter = 0\\n for elem in satz:\\n if elem.isupper():\\n counter += 1\\n return counter\\n\\n counting_caps(satz)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.19\\/_downloads\\/e5c0288e15772e4fb31189b766e9d7be\\/plot_metadata_epochs.ipynb\\\".\\nThe first task is:\\nWe can use this metadata attribute to select subsets of Epochs. This\\nuses the Pandas :meth:pandas.DataFrame.query method under the hood.\\nAny valid query string will work. Below we'll make two plots to compare\\nbetween them:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nav1 = epochs['Concreteness < 5 and WordFrequency < 2'].average()\\nav2 = epochs['Concreteness > 5 and WordFrequency > 2'].average()\\n\\njoint_kwargs = dict(ts_args=dict(time_unit='s'),\\n topomap_args=dict(time_unit='s'))\\nav1.plot_joint(show=False, **joint_kwargs)\\nav2.plot_joint(show=False, **joint_kwargs)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"6_Optimization_Integration_ODEs.ipynb\\\".\\nThe first task is:\\nMuch better!\\nObviously this is not great as in general you may not know a good starting parameter value (although you should have an idea of bounds and constraints especially if your model is not too abstract).\\nOne way of getting around this is to initialise your fitting function from a bounded range of random initial values and choosing some that are markedly better.\\nSome optimisation routines will do (basically) this internally.\\nAnother option is to choose a more robust optimisation method.\\nMore general minimization\\nscipy.optimize contains a fairly wide range of optimization routines.\\nIn general these aim to minimize some generic function, rather than to 'fit a curve' as we did a moment ago.\\nTherefore, in order to fit a model to some data using these methods, we must formulate an objective function.\\nThis function can simply compute the distance, or error, between our desired outcome (the measured data) and the current output of the model.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef objective_function(par):\\n \\\"\\\"\\\"Compute the sum of squares difference between the measured data and model output.\\\"\\\"\\\"\\n # The current model prediction, based on the current parameters' values\\n y_model = sinus(x, *par)\\n # Sum-of-squares difference between the model and 'measured' data\\n return np.sum(np.power(y_measured - y_model, 2.0))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Crawling_Basics.ipynb\\\".\\nThe first task is:\\nmove from unicode to ascii:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfor string in soup.strings:\\n print(repr(string))\\n print repr(string.encode(\\\"ascii\\\"))\\n print\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# make cube files\\n# forte.utils.psi4_cubeprop(wfn,path='cubes',nocc=5,nvir=0, load=True)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLastly, we can optionally generate cube files for all the occupied orbitals and visualize them. The resulting orbitals consist of a core orbital (which cannot be seen) and four localized C-H $\\\\sigma$ bond orbitals\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"08_Writing_Reading_Files_Lecture.ipynb\\\".\\nThe first task is:\\nWhen you try to print the variable created, you will not get what you want. It is just an object created to use in later statements. \\n\\nTo open a file the open function used with parameter 'w'\\nCan you write Python code for it?\\n\",\"targets\":\"\\noutput_file = open('data\\/mynewfile.txt', 'w') # I used data\\/name because I want to save in data folder\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Check out your predictions\\nHere, use the test data to view how well your network is modeling the data. If something is completely wrong here, make sure each step in your network is implemented correctly.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfig, ax = plt.subplots(figsize=(8,4))\\n\\nmean, std = scaled_features['cnt']\\npredictions = network.run(test_features)*std + mean\\nax.plot(predictions[0], label='Prediction')\\nax.plot((test_targets['cnt']*std + mean).values, label='Data')\\nax.set_xlim(right=len(predictions))\\nax.legend()\\n\\ndates = pd.to_datetime(rides.ix[test_data.index]['dteday'])\\ndates = dates.apply(lambda d: d.strftime('%b %d'))\\nax.set_xticks(np.arange(len(dates))[12::24])\\n_ = ax.set_xticklabels(dates[12::24], rotation=45)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2. Network(X) Basics (Instructor).ipynb\\\".\\nThe first task is:\\nEdges can also store attributes in their attribute dictionary.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nG.edges(data=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create a Cloud Storage bucket\\nThe following steps are required, regardless of your notebook environment.\\nWhen you submit a training job using the Cloud SDK, you upload a Python package\\ncontaining your training code to a Cloud Storage bucket. Vertex AI runs\\nthe code from this package. In this tutorial, Vertex AI also saves the\\ntrained model that results from your job in the same bucket. Using this model artifact, you can then\\ncreate Vertex AI model and endpoint resources in order to serve\\nonline predictions.\\nSet the name of your Cloud Storage bucket below. It must be unique across all\\nCloud Storage buckets.\\nYou may also change the REGION variable, which is used for operations\\nthroughout the rest of this notebook. Make sure to choose a region where Vertex AI services are\\navailable. You may\\nnot use a Multi-Regional Storage bucket for training with Vertex AI.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nBUCKET_NAME = \\\"gs:\\/\\/[your-bucket-name]\\\" # @param {type:\\\"string\\\"}\\nREGION = \\\"us-central1\\\" # @param {type:\\\"string\\\"}\\n\\nif BUCKET_NAME == \\\"\\\" or BUCKET_NAME is None or BUCKET_NAME == \\\"gs:\\/\\/[your-bucket-name]\\\":\\n BUCKET_NAME = \\\"gs:\\/\\/\\\" + PROJECT_ID + \\\"aip-\\\" + TIMESTAMP\\nprint(BUCKET_NAME)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Analyze results\\nTo make the analysis of the factors more interesting, we'll restrict it to the top 2000 most popular movies.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ng=ratings.groupby('movieId')['rating'].count()\\ntop_movies=g.sort_values(ascending=False)[:2000]\\ntop_movies = torch.LongTensor(np.array(top_movies.index))\\ntop_movies[:5]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2_Systems_Of_Equations.ipynb\\\".\\nThe first task is:\\nGauss-Seidel Method\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef gauss_seidel_method(A, b, x0, k):\\n \\\"\\\"\\\"\\n Use gauss seidel method to solve equations\\n \\n Args:\\n A (numpy 2d array): the matrix\\n b (numpy 1d array): the right hand side vector\\n x0 (numpy 1d array): initial guess\\n k (real number): iterations\\n \\n Return:\\n The approximate solution\\n \\n Exceptions:\\n ValueError\\n The size of matrix's column is not equal to the size of vector's size\\n \\\"\\\"\\\"\\n if A.shape[1] is not x0.shape[0] :\\n raise ValueError('The size of the columns of matrix A must be equal to the size of the x0')\\n \\n D = np.diag(A.diagonal())\\n L = np.tril(A) - D\\n U = np.triu(A) - D\\n inv_LD = linalg.inv(L + D)\\n xk = x0\\n \\n for _ in range(k):\\n xk = np.matmul(inv_LD, -np.matmul(U, xk) + b)\\n \\n return xk\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Experimental\\/SVMDocs.ipynb\\\".\\nThe first task is:\\nThis file has 23 features and 10,341 data points. Clearly not all of these features are useful for training a model. For example we have date and location. By applying principal component analysis (https:\\/\\/en.wikipedia.org\\/wiki\\/Principal_component_analysis) to our data we decided that the 7 features: 'avgTemp', 'avgWind', '14dayAvgTemp', '14dayAvgHum' and '14DayAvgRain' were most conducive to values in the 'Fire' column for whom a 1 corresponds to their being a fire and a 0 to no fire. Next came model selection. Due to the relatively small amount of data we had relative to the number of useful features we opted to go with a Support Vector Machine based model.\\nSupport Vector Machines\\nA Support Vector Machine (or SVM for short) is a supervised ML method that can be used for classification of data. Each data item is plotted in n-dimensional space (where n corresponds to the number of features) and then classification is performed by finding a hyperplane that differentiates the classes of the data well. It does so by finding vectors (data points) belonging to each class and basing the position of the hyperplane upon the position of these vectors. These vectors are known as support vectors hence the name.\\n\\nSVM's work particuarly well when the order of the feature-space is large (as in our case) because as its size increases its more likely that the classes will form distinct clusters allowing for a better fitting hyperplane. In addition having a relatively small amount of data isn't game over as presuming the classes form relatively tight data clusters hyperplanes fitted to larger datasets will still be in a similar place to smaller datasets. It is for these reasons we opted to go with a SVM model to make our predictions. Obviously we are assuming that our relatively small dataset is representative of what datap in the class generally looks like and training on a larger dataset likely wouldnt hurt. This is something we would like to improve our model by doing if provided with the resources.\\nA SVM in the context of...\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport pandas as pd\\nfrom sklearn.model_selection import train_test_split\\nfrom sklearn import preprocessing\\ndf = pd.io.parsers.read_csv(\\n 'Data\\/NewBalanced.csv',\\n header=None,\\n skiprows = [0],\\n usecols=[5,10,15,17,18,19,20,22]\\n)\\n\\nX = df.values[:,:7]\\n\\ny = df.values[:,7]\\n\\n#split the data into training and testing data\\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=12345)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#Pairwise distance calculations are going in here\\nsame_dists = np.empty((0,1))\\ndiff_dists = np.empty((0,1))\\n\\nfor labInstance in np.unique(train_labels):\\n dists = pdist(train_samples[train_labels==labInstance,:],DISTANCE_METRIC)\\n # this is already the condensed-form (lower triangle) with no duplicate comparisons.\\n same_dists = np.append(same_dists, np.array(dists))\\n del dists\\n \\n dists = cdist(train_samples[train_labels==labInstance,:], train_samples[train_labels!=labInstance,:], DISTANCE_METRIC)\\n #print dists.shape\\n train_samples[train_labels!=labInstance,:]\\n diff_dists = np.append(diff_dists, np.array(dists).flatten())\\n#print same_dists.shape\\n#print diff_dists.shape\\n\\nminval = min(np.min(diff_dists),np.min(same_dists))\\nmaxval = max(np.max(diff_dists),np.max(same_dists))\\n\\n# plot the histograms to see difference in distributions\\n# Same source data \\nmu_s, std_s = norm.fit(same_dists) # fit the intensities wth a normal\\nplt.hist(same_dists, np.arange(minval, maxval, abs(minval-maxval)\\/100), normed=1, facecolor='green', alpha=0.65)\\ny_same = mlab.normpdf(np.arange(minval, maxval, abs(minval-maxval)\\/100), mu_s, std_s) # estimate the pdf over the plot range\\nl=plt.plot(np.arange(minval, maxval, abs(minval-maxval)\\/100), y_same, 'g--', linewidth=1)\\n\\n# Different source data\\nmu_d, std_d = norm.fit(diff_dists) # fit the intensities wth a normal\\nplt.hist(diff_dists, np.arange(minval, maxval, abs(minval-maxval)\\/100), normed=1, facecolor='blue', alpha=0.65)\\ny_diff = mlab.normpdf(np.arange(minval, maxval, abs(minval-maxval)\\/100), mu_d, std_d) # estimate the pdf over the plot range\\nl=plt.plot(np.arange(minval, maxval, abs(minval-maxval)\\/100), y_diff, 'b--', linewidth=1)\\n\\nprint('same source comparisons made: ', same_dists.shape[0])\\nprint('diff source comparisons made: ', diff_dists.shape[0])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nModeling the general sense of similarity\\nThe following code cell does a lot of the work necessary to get from multivariate data to univariate score-based likelihood ratios\\nIf you attended the lecture from Jacob about score-based LRs then this should be very familiar!\\n\\nFirst, pair wise comparisons are where source identity is known (because the data was generated with a ground truth)\\nThe comparisons are accumalated into groups based on the source identity same or different batch\\nThe acumalated score distributions are modeled using a probability density function\\nThe parameters of those distributions and a graphical representation is displayed\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"As we saw above, some words map to multiple tokens:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nbert_tokenizer.tokenize('snuffleupagus')\\n\\nsubtok_ids = vsm.hf_encode(\\\"snuffleupagus\\\", bert_tokenizer)\\n\\nsubtok_ids\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Adding a column to the Table\\n\",\"targets\":\"perihelion = planet_table['a'] * (1.0 - planet_table['ecc'])\\n\\nperihelion\\n\\nplanet_table['Peri'] = perihelion\\n\\nplanet_table\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Build the Neural Network\\nApply the functions you implemented above to:\\n\\nApply embedding to the input data for the encoder.\\nEncode the input using your encoding_layer(rnn_inputs, rnn_size, num_layers, keep_prob).\\nProcess target data using your process_decoding_input(target_data, target_vocab_to_int, batch_size) function.\\nApply embedding to the target data for the decoder.\\nDecode the encoded input using your decoding_layer(dec_embed_input, dec_embeddings, encoder_state, vocab_size, sequence_length, rnn_size, num_layers, target_vocab_to_int, keep_prob).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef seq2seq_model(input_data, target_data, keep_prob, batch_size, sequence_length, source_vocab_size, target_vocab_size,\\n enc_embedding_size, dec_embedding_size, rnn_size, num_layers, target_vocab_to_int):\\n \\\"\\\"\\\"\\n Build the Sequence-to-Sequence part of the neural network\\n :param input_data: Input placeholder\\n :param target_data: Target placeholder\\n :param keep_prob: Dropout keep probability placeholder\\n :param batch_size: Batch Size\\n :param sequence_length: Sequence Length\\n :param source_vocab_size: Source vocabulary size\\n :param target_vocab_size: Target vocabulary size\\n :param enc_embedding_size: Decoder embedding size\\n :param dec_embedding_size: Encoder embedding size\\n :param rnn_size: RNN Size\\n :param num_layers: Number of layers\\n :param target_vocab_to_int: Dictionary to go from the target words to an id\\n :return: Tuple of (Training Logits, Inference Logits)\\n \\\"\\\"\\\"\\n # TODO: Implement Function\\n rnn_inputs = tf.contrib.layers.embed_sequence(input_data, source_vocab_size,\\n enc_embedding_size)\\n \\n encoder_state = encoding_layer(rnn_inputs, rnn_size, num_layers, keep_prob)\\n \\n dec_input = process_decoding_input(target_data, target_vocab_to_int, batch_size)\\n dec_embeddings = tf.Variable(tf.random_uniform([target_vocab_size, dec_embedding_size]))\\n dec_embed_input = tf.nn.embedding_lookup(dec_embeddings, dec_input)\\n \\n output = decoding_layer(dec_embed_input, dec_embeddings, encoder_state, target_vocab_size, sequence_length,\\n rnn_size, num_layers, target_vocab_to_int, keep_prob)\\n return output\\n\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_seq2seq_model(seq2seq_model)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"08-notebook.ipynb\\\".\\nThe first task is:\\nHier sollte ausschließlich Keine Analyse möglich stehen:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntest_grammar(grammar, neg_sentences)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"02 strings and text\\/02.15 interpolating variables in strings.ipynb\\\".\\nThe first task is:\\nvars() 还有一个有意思的特性就是它也适用于对象实例。比如：\\nCan you write Python code for it?\\n\",\"targets\":\"\\nclass Info:\\n def __init__(self, name, n):\\n self.name = name\\n self.n = n\\n\\na = Info(\\\"Guido\\\", 37)\\ns.format_map(vars(a))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Because x is a placeholder, linear_model can be evaluated for several x values simultaneously:\\n\",\"targets\":\"Sessionprint(sess.run(linear_model, {x: [1, 2, 3, 4]}))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A limitation of the transmit signal energy is known.\\n$\\\\boldsymbol{x}^T\\\\boldsymbol{x} \\\\leq 1$.\\nWe add this information as a constraint to the problem with the use\\nof a Lagrange multiplier. \\nUse gradient descent direction to find the optimal $\\\\boldsymbol{x}$ of the new constrained\\nproblem.\\n\",\"targets\":\"max_iter = 100000\\nlam = 5 # Init value for lambda.\\ninit_xg = np.random.rand(*x.shape)*1.4 # Initial guess.\\nxg = init_xg\\n\\npoints = []\\nwhile len(points) < max_iter:\\n points.append(xg)\\n xg = np.linalg.inv(H.T.dot(H)+lam*np.identity(n)).dot(H.T).dot(y)\\n lam = lam - epsilon*(1-xg.T.dot(xg))\\n if np.abs(1-xg.T.dot(xg)) < delta or lam < delta:\\n break\\nprint(xg)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#People who respond 1 have used Adderall non-medically; no one else has. \\nnsduh_data['ADDERALL'] = (nsduh_data['ADDERALL'] == 1)*1.\\nnsduh_data['RITALIN'] = (nsduh_data['RITMPHEN'] == 1)*1.\\n\\n\\ndef stratifyByCat(nsduh_data, cat, drug_to_measure = 'ADDERALL', sortByVal = False):\\n \\\"\\\"\\\"\\n Checked. Computes the weighted and unweighted mean values of Adderall, stratifying by \\n the levels in cat. \\n \\\"\\\"\\\"\\n levels = sorted(list(set(nsduh_data[cat].dropna())))\\n print 'Category', cat\\n table = []\\n for l in levels:\\n idxs = nsduh_data[cat] == l\\n summed_weights = nsduh_data.loc[idxs]['ANALWT_C'].sum()\\n mu = (nsduh_data.loc[idxs][drug_to_measure] * nsduh_data.loc[idxs]['ANALWT_C']).sum() \\/ summed_weights\\n unweighted_mu = nsduh_data.loc[idxs][drug_to_measure].mean()\\n if idxs.sum() > 25:\\n table.append([drug_to_measure, l, mu, unweighted_mu, idxs.sum()])\\n if sortByVal:\\n table = sorted(table, key = lambda x:x[2])[::-1]\\n for row in table:\\n print 'Mean value of %s for level %s is %2.3f; unweighted, %2.3f (%i values)' % (tuple(row))\\n print 'Ratio between maximum value and minimum value', max([a[2] for a in table]) \\/ min([a[2] for a in table])\\nprint 'COLLENR levels:\\\\n1: FT college students age 18 - 22; 2: other age 18 - 22; 3: other'\\nstratifyByCat(nsduh_data, 'COLLENR') \\nstratifyByCat(nsduh_data, 'COLLENR', drug_to_measure = 'RITALIN') \\n\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n\\\"When I looked at more recent data (the 2013 National Survey on Drug Use and Health (NSDUH), an annual government survey that includes more than 55,000 Americans) the difference turned out to be closer to 1.3x, not 2x.\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Data_Analysis\\/data_analysis_with_CDO.ipynb\\\".\\nThe first task is:\\nList CDO operators\\nMore than 800 operators are available.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(len(dict(list(cdo.operators.items()))))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"After cloning the above repo we can important pandas and our custom module time_series.py.\\n\",\"targets\":\"%matplotlib inline\\nimport pandas as pd\\nimport pandas_gbq as gbq\\n\\nfrom sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor\\nfrom sklearn.linear_model import Ridge\\n\\nimport time_series\\n\\n# Allow you to easily have Python variables in SQL query.\\nfrom IPython.core.magic import register_cell_magic\\nfrom IPython import get_ipython\\n\\n\\n@register_cell_magic('with_globals')\\ndef with_globals(line, cell):\\n contents = cell.format(**globals())\\n if 'print' in line:\\n print(contents)\\n get_ipython().run_cell(contents)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# create a new dataframe with unique project code and name\\n\\nroot = document.getroot()\\ndfcntry = []\\nfor country in root.findall('country'):\\n dfcntry.append([country.attrib['car_code'], country.find('name').text])\\n \\ndfcntry = pd.DataFrame(dfcntry, columns=['country_code','country_name']) \\ndfUniq = dfcntry[(dfcntry.country_name != '')].drop_duplicates('country_code')\\ndfUniq = pd.DataFrame(dfUniq, columns=['country_code','country_name']) \\n\\n# gather all data into a list\\ndf = [] \\nfor airport in root.findall('airport'): \\n area = airport.find('elevation')\\n airportname = airport.find('name')\\n if area.text != None:\\n df.append([airport.attrib['country'], airportname.text, pd.to_numeric(area.text)])\\n\\n# convert into a dataframe\\ndf = pd.DataFrame(df, columns = ['country_code', 'airport_name', 'elevation'])\\n\\n# get country with highest elevation\\ndf = df.sort_values(['elevation'], ascending=[0]).head(1).reset_index(drop=True)\\n\\n# locate the country names from list of unique country codes\\ndfCntry = dfUniq.loc[dfUniq['country_code'] == df['country_code'].values[0]] \\n\\n# merge two dataframes, print answer\\ndf = pd.merge(dfCntry, df, on='country_code', how='outer')\\n\\n# i don't want to display country code\\ndel df['country_code']\\ndf\\n \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nname and country of c) airport at highest elevation\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Creating arrays of ones or zeros can also be useful as placeholder arrays, in cases where we do not want to use the initial values for computations but want to fill it with other values right away. If we do not need the initial values (for instance, '0.' or '1.'), there is also numpy.empty, which follows the same syntax as numpy.ones and np.zeros. However, instead of filling the array with a particular value, the empty function creates the array with non-sensical values from memory. We can think of zeros as a function that creates the array via empty and then sets all its values to 0. -- in practice, a difference in speed is not noticeable, though. \\nNumPy also comes with functions to create identity matrices and diagonal matrices as ndarrays that can be useful in the context of linear algebra -- a topic that we will explore later in this appendix.\\n\",\"targets\":\"np.eye(3)\\n\\nnp.diag((3, 3, 3))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Before we begin - download the LIGO data necessary for this notebook. This download may take a bit of time.\\nProblem 1) Detector Noise Curves\\nRead in the Hanford (H1) and Livingston (L1) amplitude spectral densities (ASD) data files (H1-ASD.txt, L1-ASD.txt).\\n\",\"targets\":\"# Load the ASD data\\ndir = '.\\/Matched_Filter_Data\\/' #point to your local directory containing the data files\\n\\nH1 = pd.read_csv(dir+'H1-ASD.txt', delim_whitespace=True)\\nL1 = pd.read_csv(dir+'L1-ASD.txt', delim_whitespace=True)\\n\\nH1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"As you can see, if not both of the indices are present then Pandas will return NaNs.\\nPandas uses numpy heavily underneath, so many of the numpy array operations work on Series as well:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncolours.mean(), colours.max()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"By now it should be clear that the vector feature with id=10 stands for the question \\\"How many\\ntimes does the word graph appear in the document?\\\" and that the answer is \\\"zero\\\" for\\nthe first six documents and \\\"one\\\" for the remaining three.\\nCorpus Streaming -- One Document at a Time\\nNote that corpus above resides fully in memory, as a plain Python list.\\nIn this simple example, it doesn't matter much, but just to make things clear,\\nlet's assume there are millions of documents in the corpus. Storing all of them in RAM won't do.\\nInstead, let's assume the documents are stored in a file on disk, one document per line. Gensim\\nonly requires that a corpus must be able to return one document vector at a time:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom smart_open import open # for transparently opening remote files\\n\\n\\nclass MyCorpus(object):\\n def __iter__(self):\\n for line in open('https:\\/\\/radimrehurek.com\\/gensim\\/mycorpus.txt'):\\n # assume there's one document per line, tokens separated by whitespace\\n yield dictionary.doc2bow(line.lower().split())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"A Beginners Guide to Python\\/25. Introduction to Testing.ipynb\\\".\\nThe first task is:\\nOkay, now that we have a solution, lets run the tests:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint_test_result(firstMissingPositive, [1,2,3], 4)\\nprint_test_result(firstMissingPositive, [0,0,1], 2)\\nprint_test_result(firstMissingPositive, [1,2], 3)\\nprint_test_result(firstMissingPositive, [7,6,5,4,3,2], 1)\\nprint_test_result(firstMissingPositive, [1,2,4], 3)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"4.3. Dependency Parser\\nThe dependency parser aims at syntatic analysis of the text. It is the component that identifies the relation among the tokens in the given text, e.g., noun-chunks, verb objects, dependent clauses, etc.\\nSince our goal here is to use the pipeline to obtain BoW representation of the documents, we will not go deeper in the description of this component. If you are interested in learning more about dependy parsing in spaCy, you can check the official documentation\\nSince we will not be using this information, we can disable the component in the pipeline. This will also speed up document preprocessing.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnlp.disable_pipe(\\\"parser\\\")\\n\\n#If you wish to completely remove the component from the pipeline, you can use the following command\\n#nlp.remove_pipe(\\\"parser\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# generator network\\ndef generator(z, batch_size, z_dim):\\n # z_dim:(100, ) => (3136, ) => (56, 56, 1) => bn => relu\\n g_w1 = tf.get_variable('g_w1', [z_dim, 3136], dtype=tf.float32,\\n initializer=tf.truncated_normal_initializer(stddev=0.02))\\n g_b1 = tf.get_variable('g_b1', [3136],\\n initializer=tf.truncated_normal_initializer(stddev=0.02))\\n g1 = tf.matmul(z, g_w1) + g_b1\\n g1 = tf.reshape(g1, [-1, 56, 56, 1])\\n g1 = tf.contrib.layers.batch_norm(g1, epsilon=1e-5, scope='bn1')\\n g1 = tf.nn.relu(g1)\\n \\n # Generate 50 features\\n # (56, 56, 1) => (28, 28, 1) => (56, 56, 50) => bn => relu\\n g_w2 = tf.get_variable('g_w2', [3, 3, 1, z_dim \\/ 2], dtype=tf.float32,\\n initializer=tf.truncated_normal_initializer(stddev=0.02))\\n g_b2 = tf.get_variable('g_b2', [z_dim \\/ 2],\\n initializer=tf.truncated_normal_initializer(stddev=0.02))\\n g2 = tf.nn.conv2d(g1, g_w2, strides=[1, 2, 2, 1], padding='SAME')\\n g2 = g2 + g_b2\\n g2 = tf.contrib.layers.batch_norm(g2, epsilon=1e-5, scope='bn2')\\n g2 = tf.nn.relu(g2)\\n g2 = tf.image.resize_images(g2, [56, 56])\\n \\n # Generate 25 features\\n # (56, 56, 50) => (28, 28, 25) => (56, 56, 25) => bn => relu\\n g_w3 = tf.get_variable('g_w3', [3, 3, z_dim \\/ 2, z_dim \\/ 4], dtype=tf.float32,\\n initializer=tf.truncated_normal_initializer(stddev=0.02))\\n g_b3 = tf.get_variable('g_b3', [z_dim \\/ 4],\\n initializer=tf.truncated_normal_initializer(stddev=0.02))\\n g3 = tf.nn.conv2d(g2, g_w3, strides=[1, 2, 2, 1], padding='SAME')\\n g3 = g3 + g_b3\\n g3 = tf.contrib.layers.batch_norm(g3, epsilon=1e-5, scope='bn3')\\n g3 = tf.nn.relu(g3)\\n g3 = tf.image.resize_images(g3, [56, 56])\\n \\n # Final convolution with one output channel\\n # (56, 56, 25) => (28, 28, 1)\\n g_w4 = tf.get_variable('g_w4', [1, 1, z_dim \\/ 4, 1], dtype=np.float32,\\n ...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nd_w1はフィルタの重み 5x5で1チャンネル入力、32チャンネル（特徴マップ）出力の意味\\ntensorflowのstridesは[1, stride, stride, 1]と[0]と[3]は必ず1で固定する\\ndiscriminatorにbatch normは入れていない\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Proyecto de Grado Ingeniería Electrónica\\/Workspace\\/RL\\/TowardsRL\\/.ipynb_checkpoints\\/reinforcement_q_learning-checkpoint.ipynb\\\".\\nThe first task is:\\nInput extraction\\n^^^^^^^^^^^^^^^^\\nThe code below are utilities for extracting and processing rendered\\nimages from the environment. It uses the torchvision package, which\\nmakes it easy to compose image transforms. Once you run the cell it will\\ndisplay an example patch that it extracted.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nresize = T.Compose([T.ToPILImage(),\\n T.Scale(40, interpolation=Image.CUBIC),\\n T.ToTensor()])\\n\\n# This is based on the code from gym.\\nscreen_width = 600\\n\\ndef get_cart_location():\\n world_width = env.x_threshold * 2\\n scale = screen_width \\/ world_width\\n return int(env.state[0] * scale + screen_width \\/ 2.0) # MIDDLE OF CART\\n\\n\\ndef get_screen():\\n screen = env.render(mode='rgb_array').transpose(\\n (2, 0, 1)) # transpose into torch order (CHW)\\n # Strip off the top and bottom of the screen\\n screen = screen[:, 160:320]\\n view_width = 320\\n cart_location = get_cart_location()\\n if cart_location < view_width \\/\\/ 2:\\n slice_range = slice(view_width)\\n elif cart_location > (screen_width - view_width \\/\\/ 2):\\n slice_range = slice(-view_width, None)\\n else:\\n slice_range = slice(cart_location - view_width \\/\\/ 2,\\n cart_location + view_width \\/\\/ 2)\\n # Strip off the edges, so that we have a square image centered on a cart\\n screen = screen[:, :, slice_range]\\n # Convert to float, rescare, convert to torch tensor\\n # (this doesn't require a copy)\\n screen = np.ascontiguousarray(screen, dtype=np.float32) \\/ 255\\n screen = torch.from_numpy(screen)\\n # Resize, and add a batch dimension (BCHW)\\n return resize(screen).unsqueeze(0)\\n\\nenv.reset()\\nplt.imshow(get_screen().squeeze(0).permute(1, 2, 0).numpy(), interpolation='none')\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Add Columns from Complete DataFrame to Matching Records of the Incomplete DataFrame\\nNow that the matches are found you can pull in information from the complete dataframe by using merge_lists and just specifying a list of columns from the complete dataframe you want.\\nColumns of the same name will have a suffix added to the column name in the result dataframe.\\n\",\"targets\":\"output = match.merge_lists(partial, complete, \\n matching_indices=matches_found, \\n wanted_cols=['email'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# MSE\\nloss = tf.reduce_mean(tf.square(outputs - y))\\noptimizer = tf.train.AdamOptimizer(learning_rate = learning_rate)\\ntrain = optimizer.minimize(loss)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLoss Function and Optimizer\\n Create a Mean Squared Error Loss Function and use it to minimize an AdamOptimizer, remember to pass in your learning rate.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# regex_runtime = r\\\" minutes\\\"\\n# subset = \\\"\\\"\\n\\n# who\\n\\n# movie_db = unpickle_object(\\\"movie_database_final.pkl\\\")\\n\\n# movie_df = pd.DataFrame.from_items(movie_db.items(), \\n# orient='index', \\n# columns=['A','B','C','D',\\\"E\\\",'F',\\\"G\\\", 'H', \\\"I\\\", \\\"J\\\", \\\"K\\\", \\\"L\\\"])\\n\\n\\n# del movie_df['F']\\n\\n# movie_df.columns = ['Rank_in_genre', \\\"rotton_rating_(\\/10)\\\", \\\"No._of_reviews_rotton\\\",\\\"Tomato_Freshness_(%)\\\", \\\"audience_rating_(\\/5)\\\", \\\"Date\\\", \\\"Runtime\\\", \\\"Box_office\\\", \\\"Budget\\\", \\\"Country\\\",\\\"Language\\\" ]\\n\\n# movie_df.head()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThis notebook contains the final bits of code that was used to clean up my data before having it ready for analysis.\\nAll commands have been commented out to avoid any data corruption\\/errors.\\nData cleaning is an incredibly important skill - in some sense, I am thankful that this project was messy as it puched me to be creative in my cleaning techniques.\\nThe entire scraping and cleaning process for the project too approximately 1 week.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# split is very useful when parsing files\\ns = 'first second third'\\ns.split()\\n\\n# a different character can be used as well as separator\\ns = 'first,second,third'\\ns.split(',')\\n\\n# Upper is a very easy and handy method\\ns.upper()\\n\\n# Methods can be chained as well!\\ns.upper().lower().split(',')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWell, that's a lot ! Here are the common useful ones:\\n- split\\n- find\\n- index\\n- replace\\n- lower\\n- upper\\n- endswith\\n- startswith\\n- strip\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"As mentioned before, tuples are immutable. You can't change any part of them without defining a new tuple.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmy_tuple[3] = 'dogs' # Attempts to change the 'cats' value stored in the the tuple to 'dogs'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Daily\\/20150912_mag_profiles.ipynb\\\".\\nThe first task is:\\nNow we can load other files containing the density structures.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ng_grad = np.genfromtxt('files\\/gauss.grad')\\nd_grad = np.genfromtxt('files\\/dipole.grad')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Data Augmentation\\n\\nWe expand the input data to be acted on by the convolutional layer.\\n\",\"targets\":\"conv_domain = 11\\n\\n# Reproducibility\\nnp.random.seed(7) \\n# Load data\\n\\ndef expand_dims(input):\\n r = int((conv_domain-1)\\/2)\\n l = input.shape[0]\\n n_input_vars = input.shape[1]\\n output = np.zeros((l, conv_domain, n_input_vars))\\n for i in range(l):\\n for j in range(conv_domain):\\n for k in range(n_input_vars):\\n output[i,j,k] = input[min(i+j-r,l-1),k]\\n return output\\n\\nX_train = np.empty((0,conv_domain,8), dtype=float)\\nX_test = np.empty((0,conv_domain,8), dtype=float)\\n\\nwellId = 0.0\\nfor i in range(10):\\n X_train_subset = X_train_in[X_train_in[:, 8] == wellId][:,0:8]\\n X_train_subset = expand_dims(X_train_subset)\\n X_train = np.concatenate((X_train,X_train_subset),axis=0)\\n wellId = wellId + 1.0\\n \\nfor i in range(2):\\n X_test_subset = X_test_in[X_test_in[:, 8] == wellId][:,0:8]\\n X_test_subset = expand_dims(X_test_subset)\\n X_test = np.concatenate((X_test,X_test_subset),axis=0)\\n wellId = wellId + 1.0\\n \\nprint(X_train.shape)\\nprint(X_test.shape)\\n\\n# Obtain labels\\ny_labels = np.zeros((len(y_train),1))\\nfor i in range(len(y_train)):\\n y_labels[i] = np.argmax(y_train[i])\\ny_labels = y_labels.astype(int)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# exercise 10\\n# Put your solution here!\\n# finding error_rate from prediction accuracy\\nfit = smf.glm('HIGH_BP ~ sFRW + SEX + SEX:sFRW + sAGE * SEX + sAGE:sFRW', data=fram, family=sm.families.Binomial()).fit()\\n# print(fit.summary())\\n\\nerror_rate = np.mean(((fit.fittedvalues < 0.5) & fram.HIGH_BP) |\\n((fit.fittedvalues > 0.5) & ~fram.HIGH_BP))\\nprint(\\\"Original error rate :%0.4f \\\\nNewly computer error rate: %0.4f\\\" % (error_rate_orig, error_rate))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAdd the sAGE variable and its interactions. Check the prediction accuracy of the model and compare it to the previous model. Store the prediction accuracy to variable error_rate.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Assignment (5 min):<\\/span> Compare reaction r0399 and the PHETHPTOX2 reaction. What is their relationship? Are they encoded by the same gene or different genes? Check this.\\nAssignment (5 min):<\\/span> Investigate the reactions of tetrahydrobiopterin and dihydrobiopterin. How does the recycling occur?\\nA simple representation of the core network surrounding PAH mutation that leads to PKU\\n\\nAssignment (5 min):<\\/span> Discuss: is this simplified view of the network surround PAH and the BH4 co-factor correctly describing the RECON 2 network?\\nTo investigate PKU we will ask the model for growth before and after the mutation in the PHETHPTOX2 gene. \\nWe require that there is always a base level of growth (0.5, arbitrary) so that the model is forced to predict a flux distribution in which growth is occuring.\\n\",\"targets\":\"model = M.copy()\\nfvarxns = [model.reactions.r0399, model.reactions.PHETHPTOX2]\\ncobra.flux_analysis.flux_variability_analysis(model,reaction_list=fvarxns,fraction_of_optimum=0.5)[['minimum','maximum']]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"1-pandas.ipynb\\\".\\nThe first task is:\\nДанные вначале нашего df\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!head -n 13 .\\/camera_traj.json\\n\\nimport json\\ncamera_trajectory = json.load(open('camera_traj.json'))\\nprint camera_trajectory[0] # camera location and rotation\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nRead a camera trajectory from a file\\nWe will read a camera trajectory from camera_traj.json. This file contains a camera trajectory with 10 frames. The camera trajectory recorded using another python script.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Boxplot\\n\",\"targets\":\"from pyecharts import Boxplot\\n\\nboxplot = Boxplot(\\\"Box plot\\\")\\nx_axis = ['expr1', 'expr2', 'expr3', 'expr4', 'expr5']\\ny_axis = [\\n [850, 740, 900, 1070, 930, 850, 950, 980, 980, 880,\\n 1000, 980, 930, 650, 760, 810, 1000, 1000, 960, 960],\\n [960, 940, 960, 940, 880, 800, 850, 880, 900, 840,\\n 830, 790, 810, 880, 880, 830, 800, 790, 760, 800],\\n [880, 880, 880, 860, 720, 720, 620, 860, 970, 950,\\n 880, 910, 850, 870, 840, 840, 850, 840, 840, 840],\\n [890, 810, 810, 820, 800, 770, 760, 740, 750, 760,\\n 910, 920, 890, 860, 880, 720, 840, 850, 850, 780],\\n [890, 840, 780, 810, 760, 810, 790, 810, 820, 850,\\n 870, 870, 810, 740, 810, 940, 950, 800, 810, 870]\\n]\\n_yaxis = boxplot.prepare_data(y_axis) \\nboxplot.add(\\\"boxplot\\\", x_axis, _yaxis)\\nboxplot\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Define the Extents of the Analysis ▴<\\/span>\\nCHANGE INPUTS BELOW\\n\",\"targets\":\"# Select an analysis region (Lat-Lon) within the extents listed above. \\n# Select a time period (Min-Max) within the extents listed above (Year-Month-Day)\\n# This region and time period will be used for the cloud assessment\\n\\n# Nairobi, Kenya\\nlatitude = (-1.3407, -1.2809)\\nlongitude = (36.7640, 36.9206)\\n\\n# Mombasa, Kenya\\n# latitude = (-4.12, -3.975)\\n# longitude = (39.55, 39.7) \\n\\n# Mau Forest - Western Kenya\\n# latitude = (-0.13406, 0.21307)\\n# longitude = (35.28322, 35.56681)\\n\\n# Dar es Salaam, Tanzania\\n# latitude = (-7.0, -6.7)\\n# longitude = (39.1, 39.4)\\n\\n# Lake Sulunga, Tanzania\\n# latitude = (-6.2622, -5.8822) \\n# longitude = (34.9802, 35.3602) \\n\\n# Freetown, Sierra Leone\\n# latitude = (8.3267, 8.5123)\\n# longitude = (-13.3109, -13.1197 )\\n\\n# Vietnam\\n# latitude = (10.9358, 11.0358)\\n# longitude = (107.1899, 107.2899)\\n\\n# Ghanas\\n# latitude = (5.5, 5.7) # Accra\\n# longitude = (-0.4, 0.0) # Accra\\n\\n# Time Period\\ntime_extents = ('2016-01-01', '2016-01-31')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Comparisons\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmethods = [odeint, rungekutta1, rungekutta2, rungekutta4]\\nmarkers = ['+', 'o', 's', '>']\\n\\ndef test_1(n=101):\\n t = np.linspace(0, 10, n)\\n for method, m in zip(methods, markers):\\n sol = method(pend, y0, t, args=(b, c))\\n plt.plot(t, sol[:, 0], label=method.__name__, marker=m)\\n plt.legend(loc='best')\\n plt.title(\\\"Comparison of different ODE integration methods for $n={}$ points\\\".format(n))\\n plt.xlabel(\\\"$t = [0, 10]$\\\")\\n plt.grid()\\n plt.show()\\n\\ntest_1(10)\\n\\ntest_1(20)\\n\\ntest_1(100)\\n\\ntest_1(200)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create Print View List Helper Function\\nThis function will gather the current list of custom views from the HPE IMC NMS and print them out to the screen.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef print_views():\\n views_list = get_custom_views(url=auth.url, auth=auth.creds)\\n print (\\\"There are a total of \\\" + str(len(views_list)) + \\\" views currently\\\")\\n for view in views_list:\\n print (view['name'])\\n print (json.dumps(views_list[0], indent = 4))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1. Facet Grid 2 . Pair Plot\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ng = sns.FacetGrid(pokemon, col =\\\"Generation\\\", row=\\\"Legendary\\\")\\ng.map(sns.kdeplot, \\\"Attack\\\")\\nplt.show()\\n\\nsns.pairplot(pokemon[['HP', 'Attack', 'Defense']])\\nplt.show()\\n\\n\\ng = sns.PairGrid(pokemon,\\n x_vars=[\\\"Generation\\\",\\\"Legendary\\\"],\\n y_vars=[\\\"Attack\\\",\\\"Defense\\\",\\\"Sp. Atk\\\", \\\"Sp. Def\\\"],\\n aspect=.85, size=6)\\ng.map(sns.violinplot,palette=\\\"pastel\\\")\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Also remember, we should normalize our input values!\\nTODO! COMPLETE THIS SECTION!<\\/font><\\/h3>\\n\",\"targets\":\"# Normalize the input (xs) using its mean and standard deviation\\nxs = ...\\n\\n# Just to make sure you have normalized it correctly:\\nprint(np.min(xs), np.max(xs))\\nassert(np.min(xs) > -3.0 and np.max(xs) < 3.0)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3. Writing custom functions (8pts)\\nComplete the following. For some of these problems, you can use your code from previous labs as a starting point. \\n(If you didn't finish those problems, feel free to use the code from the answer sheet, just make sure you understand how they work! Optionally, for extra practice you can try re-writing them using some of the new things we've learned since then.)\\n(A) (1pt) Create a function called \\\"gc\\\" that takes a single sequence as a parameter and returns the GC content of the sequence (as a 2 decimal place float).\\n(B) (1pt) Create a function called \\\"reverse_compl\\\" that takes a single sequence as a parameter and returns the reverse complement.\\n(C) (1pt) Create a function called \\\"read_fasta\\\" that takes a file name as a parameter (which is assumed to be in fasta format), puts each fasta entry into a dictionary (using the header line as a key and the sequence as a value), and then returns the dictionary.\\n(D) (2pts) Create a function called \\\"rand_seq\\\" that takes an integer length as a parameter, and then returns a random DNA sequence of that length. \\nHint: make a list of the possible nucleotides\\n(E) (2pts) Create a function called \\\"shuffle_nt\\\" that takes a single sequence as a parameter and returns a string that is a shuffled version of the sequence (i.e. the same nucleotides, but in a random order). \\nHint: Look for Python functions that will make this easier. For example, the random module has some functions for shuffling. There may also be some built-in string functions that are useful. However, you can also do this just using things we've learned.\\n(F) (1pt) Run the code below to show that all of your functions work. Try to fix any that have problems.\\n\",\"targets\":\"##### testing gc\\ngcCont = gc(\\\"ATGGGCCCAATGG\\\")\\n\\nif type(gcCont) != float:\\n print \\\">> Problem with gc: answer is not a float, it is a %s.\\\" % type(gcCont)\\nelif gcCont != 0.62:\\n print \\\">> Problem with gc: incorrect answer (should be 0.62; your code gave\\\", gcCont, \\\")\\\" \\nelse:\\n print \\\"gc: Passed.\\\"\\n\\n\\n##### testing reverse_compl\\nrevCompl = reverse_compl(\\\"GGGGTCGATGCAAATTCAAA\\\")\\n\\nif type(revCompl) != str:\\n print \\\">> Problem with reverse_compl: answer is not a string, it is a %s.\\\" % type(revCompl) \\nelif revCompl != \\\"TTTGAATTTGCATCGACCCC\\\":\\n print \\\">> Problem with reverse_compl: answer (%s) does not match expected (%s)\\\" % (revCompl, \\\"TTTGAATTTGCATCGACCCC\\\") \\nelse:\\n print \\\"reverse_compl: Passed.\\\"\\n \\n\\n##### testing read_fasta\\ntry:\\n ins = open(\\\"horrible.fasta\\\", 'r')\\nexcept IOError:\\n print \\\">> Can not test read_fasta because horrible.fasta is missing. Please add it to the directory with this notebook.\\\"\\nelse:\\n seqDict = read_fasta(\\\"horrible.fasta\\\")\\n \\n if type(seqDict) != dict:\\n print \\\">> Problem with read_fasta: answer is not a dictionary, it is a %s.\\\" % type(seqDict)\\n elif len(seqDict) != 22:\\n print \\\">> Problem with read_fasta: # of keys in dictionary (%s) does not match expected (%s)\\\" % (len(seqDict), 22)\\n else:\\n print \\\"read_fasta: Passed.\\\"\\n\\n\\n##### testing rand_seq\\nrandSeq1 = rand_seq(23)\\nrandSeq2 = rand_seq(23)\\n\\nif type(randSeq1) != str:\\n print \\\">> Problem with rand_seq: answer is not a string, it is a %s.\\\" % type(randSeq1)\\nelif len(randSeq1) != 23:\\n print \\\">> Problem with rand_seq: answer length (%s) does not match expected (%s).\\\" % (len(randSeq1), 23)\\nelif randSeq1 == randSeq2:\\n print \\\">> Problem with rand_seq: generated the same sequence twice (%s) -- are you sure this is random?\\\" % randSeq1\\nelse:\\n print \\\"rand_seq: Passed.\\\"\\n\\n\\n##### testing shuffle_nt\\nshuffSeq = shuffle_nt(\\\"AAAAAAGTTTCCC\\\")\\n\\nif type(shuffSeq) != str:\\n print \\\">> Problem with shuffle_nt: answer is not a string, it is a %s.\\\" % type(shuffSeq)\\nelif len(shuffSeq) != 13:\\n...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Load results and create a bundles with extracted quantities for each \\n# interaction strength.\\ntrapping_3u3d_files = [\\n glob.glob(f'{data_dir}\\/trapping_3u3d\\/{u}\\/*.json')\\n for u in [0.0, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]]\\ntrapping_3u3d_bundles = [InstanceBundle(\\n experiments=[load_experiment(file) for file in files],\\n numerics_transform=parasitic_cphase_compensation(0.138),\\n steps=range(11),\\n rescale_steps=range(11)) for files in trapping_3u3d_files]\\n\\n# Simulate the exact numerical results that are used as a reference.\\ntotal_steps = sum(len(bundle.steps) for bundle in trapping_3u3d_bundles)\\nwith tqdm(range(total_steps)) as progress:\\n def post_run(_1, _2):\\n progress.update()\\n for bundle in trapping_3u3d_bundles:\\n bundle.cache_exact_numerics(post_run_func=post_run)\\n\\n# Use shared rescaling values among compatible problem instances.\\napply_rescalings_to_bundles(find_bundles_rescalings(trapping_3u3d_bundles))\\n\\nplot_quantity(trapping_3u3d_bundles, 'post_selection', show_std_dev=True);\\n\\nplot_quantity(trapping_3u3d_bundles, 'scaling', show_std_error=True);\\n\\nplot_quantity(trapping_3u3d_bundles, 'charge_spin_density', show_std_error=True);\\n\\nplot_quantity(trapping_3u3d_bundles, 'charge_spin_spreading', show_std_error=True);\\n\\nplot_quantity(trapping_3u3d_bundles, 'charge_spin_spreading_dt', show_std_error=True);\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTrapping Potential N=6\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Foundations\\/Python CS\\/Activity 09.ipynb\\\".\\nThe first task is:\\nExercise 09.3 (raising exceptions)\\nModify your program from the bisection exercise in Activity 04 to raise an error if the maximum number of iterations is exceeded. Reduce the maximum allowed iterations to test that an exception is raised.\\nAdd any other checks on the input data that you think are appropriate.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef f(x):\\n #return x**3 - 6*x**2 + 4*x + 12\\n return x**2 + x - 20 # Roots = -5, 4\\n\\ndef compute_root(f, x0, x1, tol, max_it):\\n \\\"\\\"\\\"Computes the root of f between x0 and x1 using bisection,\\n stops if the value of f at the root is under tol or if max_it is reached\\n and returns the root, the value of f at the root and the number of iterations\\\"\\\"\\\"\\n # If tolerance is less than 0 return an error\\n if tol < 0:\\n raise ValueError('Tolerance must be greater than or equal to 0')\\n \\n # If x0 or x1 is a root return it\\n if f(x0) == 0:\\n return x0, f(x0), 0\\n if f(x1) == 0:\\n return x1, f(x1), 0\\n \\n # If f(x0)*f(x1) the function has no solution in the interval, so return an error\\n if f(x0)*f(x1) > 0:\\n raise RuntimeError('There is no solution between x0 and x1')\\n \\n # Initialize iteration counter\\n i = 0\\n \\n while True:\\n # Increment counter\\n i += 1\\n # If max_it is passed return an error\\n if i > max_it:\\n raise RuntimeError('Maximum number of iterations exceeded')\\n \\n # Compute x_mid\\n x_mid = (x0 + x1) \\/ 2\\n\\n # Compute f for the three values\\n f_0, f_1, f_mid = f(x0), f(x1), f(x_mid)\\n\\n # Check the value of f_0*f_mid to determine how to update the endpoints\\n if f_0*f_mid < 0:\\n x1 = x_mid\\n else:\\n x0 = x_mid\\n \\n # Check if f is under tol\\n if abs(f_mid) < tol:\\n return x_mid, f_mid, i\\n\\n # We don't need another return statement because if we pass max_it we return an error\\n\\n# Test for the function f\\nx, f_x, num_it = compute_root(f, x0=3, x1=6, tol=1.0e-6, max_it=1000) # Ok\\n\\nprint('Approximate root:', x)\\nprint('Value of f:', f_x)\\nprint('Number of iterations:', num_it)\\n\\nprint('-----------------------------------------------------------')\\n\\nx, f_x, num_it = compute_root(f, x0=3, x1=6, tol=1.0e-6, max_it=10) # Maximum iterations exceeded\\n\\nx, f_x, num_it = compute_root(f, x0=3, x1=6, tol=-5, max_it=1000) #...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Advanced Features\\nGet optional layout parameters\\n\",\"targets\":\"res = requests.get(BASE + 'apply\\/layouts\\/force-directed')\\njp(res.json())\\n\\nparams= [\\n {\\n 'name': 'defaultNodeMass',\\n 'value': 10\\n },\\n {\\n 'name': 'defaultSpringLength',\\n 'value': 100\\n },\\n {\\n 'name': 'isDeterministic',\\n 'value': True\\n }\\n]\\nres = requests.put(BASE + 'apply\\/layouts\\/force-directed', data=json.dumps(params), headers=HEADERS)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Load the FAA N-Number inquiry records\\nfaa_tail_number_inquiry = spark.read.json('..\\/data\\/faa_tail_number_inquiry.jsonl')\\nfaa_tail_number_inquiry.show()\\n\\n# Count the records\\nfaa_tail_number_inquiry.count()\\n\\n# Load our unique tail numbers\\nunique_tail_numbers = spark.read.json('..\\/data\\/tail_numbers.jsonl')\\nunique_tail_numbers.show()\\n\\n# Join tail numbers to our inquries\\ntail_num_plus_inquiry = unique_tail_numbers.join(\\n faa_tail_number_inquiry,\\n unique_tail_numbers.TailNum == faa_tail_number_inquiry.TailNum,\\n)\\ntail_num_plus_inquiry = tail_num_plus_inquiry.drop(unique_tail_numbers.TailNum)\\ntail_num_plus_inquiry.show()\\n\\n# Dump extra field and store tail_numbers plus inquiry\\ntail_num_plus_inquiry.createOrReplaceTempView(\\\"tail_num_plus_inquiry\\\")\\nairplanes = spark.sql(\\\"\\\"\\\"SELECT\\n TailNum AS TailNum,\\n engine_manufacturer AS EngineManufacturer,\\n engine_model AS EngineModel,\\n manufacturer AS Manufacturer,\\n mfr_year AS ManufacturerYear,\\n model AS Model,\\n owner AS Owner,\\n owner_state AS OwnerState,\\n serial_number AS SerialNumber\\nFROM\\n tail_num_plus_inquiry\\\"\\\"\\\")\\n\\nairplanes.repartition(1).write.mode('overwrite').json('..\\/data\\/airplanes.json')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nInvestigating Airplanes (Entities)\\nIn Chapter 5, we were just getting into some interesting data that we will now look at once again. To begin, let’s store our enriched airplanes in their own intermediate dataset. Check out ch06\\/prepare_airplanes.py:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Правильно\\nif a is None:\\n pass\\n\\n# Неверно\\nif a == None:\\n pass\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nСравнение с None\\nСравнение с None должно осуществляться с помощью операторов is и is not, а не операторами сравнения.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Construction de tous les niveaux de l'arbre\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef tree_recursive(level, seg, angle=pi\\/6, re=0.6, rl=0.95):\\n all_segs = [seg]\\n iter_segs = [seg]\\n for i in range(level):\\n new_segs = []\\n for seg in iter_segs:\\n new_segs.extend(tree3(seg, angle=angle, re=re, rl=rl))\\n all_segs.extend(new_segs)\\n iter_segs = new_segs\\n return all_segs\\n\\npremier = segment()\\nsegs = tree_recursive(3, premier)\\ndraw(segs, L=3);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"03_problems.ipynb\\\".\\nThe first task is:\\nSolution:\\nUsing list comprehension\\nCan you write Python code for it?\\n\",\"targets\":\"\\n[(i0, i1) for i0 in l0 for i1 in l1]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Bidir\\nA second things that might help is to use a bidirectional model for the encoder.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nclass Seq2SeqQRNN(nn.Module):\\n def __init__(self, emb_enc, emb_dec, n_hid, max_len, n_layers=2, p_inp:float=0.15, p_enc:float=0.25, \\n p_dec:float=0.1, p_out:float=0.35, p_hid:float=0.05, bos_idx:int=0, pad_idx:int=1):\\n super().__init__()\\n self.n_layers,self.n_hid,self.max_len,self.bos_idx,self.pad_idx = n_layers,n_hid,max_len,bos_idx,pad_idx\\n self.emb_enc = emb_enc\\n self.emb_enc_drop = nn.Dropout(p_inp)\\n self.encoder = QRNN(emb_enc.weight.size(1), n_hid, n_layers=n_layers, dropout=p_enc, bidirectional=True)\\n self.out_enc = nn.Linear(2*n_hid, emb_enc.weight.size(1), bias=False)\\n self.hid_dp = nn.Dropout(p_hid)\\n self.emb_dec = emb_dec\\n self.decoder = QRNN(emb_dec.weight.size(1), emb_dec.weight.size(1), n_layers=n_layers, dropout=p_dec)\\n self.out_drop = nn.Dropout(p_out)\\n self.out = nn.Linear(emb_dec.weight.size(1), emb_dec.weight.size(0))\\n self.out.weight.data = self.emb_dec.weight.data\\n self.pr_force = 0.\\n \\n def forward(self, inp, targ=None):\\n bs,sl = inp.size()\\n hid = self.initHidden(bs)\\n emb = self.emb_enc_drop(self.emb_enc(inp))\\n enc_out, hid = self.encoder(emb, hid)\\n \\n hid = hid.view(2,self.n_layers, bs, self.n_hid).permute(1,2,0,3).contiguous()\\n hid = self.out_enc(self.hid_dp(hid).view(self.n_layers, bs, 2*self.n_hid))\\n\\n dec_inp = inp.new_zeros(bs).long() + self.bos_idx\\n res = []\\n for i in range(self.max_len):\\n emb = self.emb_dec(dec_inp).unsqueeze(1)\\n outp, hid = self.decoder(emb, hid)\\n outp = self.out(self.out_drop(outp[:,0]))\\n res.append(outp)\\n dec_inp = outp.data.max(1)[1]\\n if (dec_inp==self.pad_idx).all(): break\\n if (targ is not None) and (random.random()=targ.shape[1]: break\\n dec_inp = targ[:,i]\\n return torch.stack(res, dim=1)\\n \\n def initHidden(self, bs): return...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"09-Topic-Modeling\\/01-Topic-Modeling.ipynb\\\".\\nThe first task is:\\nTopic Modeling\\nLatent Dirichlet Allocation (LDA) Models\\nLDA reflects an intuition that words in a text are not merely chosen at random but are drawn from underlying concepts (the so-called \\\"latent variables\\\"). The goal of LDA is to look across many texts in order to reverse engineer these concepts by finding words that tend to cluster with one another. For this reason, LDA has been referred to as \\\"the mother of all word collocation techniques.\\\"\\nsklearn has the LatentDirichletAllocation function:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom sklearn.decomposition import LatentDirichletAllocation\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"> Compare with Matlab code - massively faster...\\n(Benchmarks on a Threadripper 1950X machine. On an Atom-based cheap laptop the python numbers here topped out at 1.4s, so were still massively faster (Matlab benchmarks were not tested on that machine).)\\n\",\"targets\":\"# Compare with Matlab benchmarks (not even funny...!)\\nx = loadmat(r'wignerD_bench_t_090819.mat') \\nwDBenchMatlab = x['wDbench']\\n\\nplt.figure(dpi = 180)\\n# plt.plot(fEvals[:,1],np.c_[tDeltas[:,0], wDBenchMatlab[1:,3]])\\nplt.plot(fEvals[:,1], tDeltas[:,0])\\nplt.plot(wDBenchMatlab[1:,2], wDBenchMatlab[1:,3])\\nplt.xlabel('Array size (func evals)')\\nplt.ylabel('t\\/s')\\nplt.show()\\n\\nprint('Check fEvals for consistency:')\\nprint(wDBenchMatlab[1:,2] - fEvals[:,1])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#**ix** will be deprecated, use **loc** for label-location based indexer\\n#df.ix[0,'Artist']\\ndf.loc[0,'Artist']\\n\\n#**ix** will be deprecated, use **loc** for label-location based indexer\\n#df.ix[1,'Artist']\\ndf.loc[1,'Artist']\\n\\n#**ix** will be deprecated, use **loc** for label-location based indexer\\n#df.ix[0,'Released']\\ndf.loc[0,'Released']\\n\\n#**ix** will be deprecated, use **loc** for label-location based indexer\\n#df.ix[1,'Released']\\ndf.loc[1,'Released']\\n\\ndf.ix[1,2]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n\\nClick here for the solution<\\/a>\\n\\n<\\/div>\\n\\n```\\ndf.ix[1,2]\\n\\nor df.iloc[0,2]\\n```\\n<\\/div>\\n\\nYou can access the column using the name as well, the following are the same as above:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"1.1.3 Variable employrate\\nThis variable is the only one who follows a Gaussian distribution, where the mean and median are almost the same. The average of the world in nearly 60% of employ rate, with slightly more countries in the upper extreme than the lower.\\n\",\"targets\":\"plot_hist('employrate')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%matplotlib inline\\nimport numpy as np\\nimport pyradi.ryfiles as ryfiles\\nimport pyradi.ryplot as ryplot\\nimport pyradi.ryplanck as ryplanck\\nimport pyradi.ryutils as ryutils\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe sensor has an aperture area of 7.8e-3 m$^2$ and a field of view of 1e-4 sr.\\nThe InSb or PbSe detector has a peak responsivity of 2.5 A\\/W and spectral\\nresponse The preamplifier transimpedance is 10000 V\\/A.\\nThe sensor filter spectral transmittance is calculated with pyradi.ryutils.sfilter and parameters $\\\\tau_s = 0.0001$, $\\\\tau_p = 0.9$, $s = 12$, $\\\\Delta\\\\lambda = 0.8$ $\\\\mu$m, $\\\\lambda_c = 4.3 \\\\mu$m.\\nThe flame area is 1 m$^2$, the flame temperature is 1000 C. The emissivity is\\n0.1 over most of the spectral band, due to carbon particles in the flame. At\\n4.3 $\\\\mu$m there is a strong emissivity rise due to the hot CO$_2$ in the flame.\\nThe emissivity can be calculated with pyradi.ryutils.sfilter and parameters $\\\\tau_s = 0.1$, $\\\\tau_p = 0.7$, $s = 6$, $\\\\Delta\\\\lambda = 0.45 \\\\mu$m, $\\\\lambda_c = 4.33 \\\\mu$m.\\nThe distance between the flame and the sensor is 1000 m. We use the Modtran\\nTropical climatic model. The path is oriented such that the sensor stares out to space,\\nat a zenith angle of 88.8 deg\\nThe peak in the flame emissivity and the dip in atmospheric transmittance are\\nboth centered around the 4.3 $\\\\mu$m CO$2$ band. In order to determine the flux\\ntransferred one must perform a spectral calculation taking these strong\\nspectral variations into account.\\nFrom (Eq 6.16), the signal caused by the atmospheric path radiance is given by\\n\\\\begin{equation}\\nv{\\\\rm path}=\\n\\\\widehat{{ R}}\\\\, Z_t \\\\,A_{1} \\\\, \\\\Omega\\\\,\\n\\\\int_{0}^{\\\\infty}\\n L_{{\\\\rm path}\\\\lambda}\\n { S}{\\\\lambda}\\nd\\\\lambda,\\n\\\\end{equation}\\nwhere \\n$\\\\widehat{{ R}}$ is the peak detector responsivity, \\n$Z_t$ is the proximity electronics (preamplifier) gain, \\n$A{1}$ the area of the sensor aperture, \\n$\\\\Omega$ is the detector solid angle field of view,\\n$L_{{\\\\rm path}}$ is the path radiance, \\n${ S}=\\\\widetilde{{ R}\\\\lambda} \\\\tau{f\\\\lambda}$,\\n$\\\\widetilde{{ R}\\\\lambda}$ is the normalised detector response, and \\n$\\\\tau{f\\\\lambda}$ is the atmospheric transmittance. Note that the path radiance term does not have an atmospheric transmittance factor because the radiance is the net effect...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Create a list\\nsampled_means = []\\n\\n# For 1000 times,\\nfor i in range(0,1000):\\n # Take a random sample of 100 rows from the population, take the mean of those rows, append to sampled_means\\n sampled_means.append(population.sample(n=100).mean().values[0])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTake A Sample Mean, Repeat 1000 Times\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# client options same for all services\\nclient_options = {\\\"api_endpoint\\\": API_ENDPOINT}\\n\\n\\ndef create_job_client():\\n client = aip.JobServiceClient(client_options=client_options)\\n return client\\n\\n\\ndef create_model_client():\\n client = aip.ModelServiceClient(client_options=client_options)\\n return client\\n\\n\\ndef create_endpoint_client():\\n client = aip.EndpointServiceClient(client_options=client_options)\\n return client\\n\\n\\ndef create_prediction_client():\\n client = aip.PredictionServiceClient(client_options=client_options)\\n return client\\n\\n\\nclients = {}\\nclients[\\\"job\\\"] = create_job_client()\\nclients[\\\"model\\\"] = create_model_client()\\nclients[\\\"endpoint\\\"] = create_endpoint_client()\\nclients[\\\"prediction\\\"] = create_prediction_client()\\n\\nfor client in clients.items():\\n print(client)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTutorial\\nNow you are ready to start creating your own custom model and training for IMDB Movie Reviews.\\nSet up clients\\nThe Vertex client library works as a client\\/server model. On your side (the Python script) you will create a client that sends requests and receives responses from the Vertex server.\\nYou will use different clients in this tutorial for different steps in the workflow. So set them all up upfront.\\n\\nModel Service for Model resources.\\nEndpoint Service for deployment.\\nJob Service for batch jobs and custom training.\\nPrediction Service for serving.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#or in megabyte;\\nopen_aq.estimate_query_size(query2) * 1000\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nand this one would cost 0.000186TB\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Correlation between max chapter and answers\\nmethod 1: correlation matrix\\nindex: question groups\\ncolumns: RedMetrics parameters\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n#def getScoresOnQuestionsFromAllData(allData, Qs):\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Finally, we create a trainingset and a testset.\\n(training_set, test_set) = raw_dataset.randomSplit([0.7, 0.3])\\ntraining_set.cache()\\ntest_set.cache()\\n\\n# Distribute the training and test set to the workers.\\ntest_set = test_set.repartition(num_workers)\\ntraining_set = training_set.repartition(num_workers)\\n\\nnum_test_set = test_set.count()\\nnum_training_set = training_set.count()\\n\\nprint(\\\"Number of testset instances: \\\" + str(num_test_set))\\nprint(\\\"Number of trainingset instances: \\\" + str(num_training_set))\\nprint(\\\"Total number of instances: \\\" + str(num_test_set + num_training_set))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFinally, we split up the dataset for training and testing purposes, and fetch some additional statistics on the number of training and testing instances.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A matrix product between a 2D array and a suitably sized 1D array result in a 1D array:\\n\",\"targets\":\"np.dot(x, np.ones(3))\\n\\nimport numpy as np\\n\\nx1 = np.array([[2,2],[3,3]])\\ny1 = np.array([[1,1],[1,1]])\\n\\ndotvalue1=x1.dot(y1)\\ndotvalue2=np.dot(x1,y1)\\n\\nprint('dotvalue1 = \\\\n', dotvalue1, '\\\\n' 'dotvalue2 = \\\\n', dotvalue2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"8.2.5 ドキュメントを分類するロジスティック回帰モデルのトレーニング\\n\",\"targets\":\"X_train = df.loc[:25000, 'review'].values\\ny_train = df.loc[:25000, 'sentiment'].values\\nX_test = df.loc[25000:, 'review'].values\\ny_test = df.loc[25000:, 'sentiment'].values\\n\\nfrom sklearn.pipeline import Pipeline\\nfrom sklearn.linear_model import LogisticRegression\\nfrom sklearn.feature_extraction.text import TfidfVectorizer\\nif Version(sklearn_version) < '0.18':\\n from sklearn.grid_search import GridSearchCV\\nelse:\\n from sklearn.model_selection import GridSearchCV\\n \\ntfidf = TfidfVectorizer(strip_accents=None,\\n lowercase=False,\\n preprocessor=None)\\nparam_grid = [{'vect__ngram_range': [(1, 1)],\\n 'vect__stop_words': [stop, None],\\n 'vect__tokenizer': [tokenizer, tokenizer_porter],\\n 'clf__penalty': ['l1', 'l2'],\\n 'clf__C': [1.0, 10.0, 100.0]},\\n {'vect__ngram_range': [(1, 1)],\\n 'vect__stop_words': [stop, None],\\n 'vect__tokenizer': [tokenizer, tokenizer_porter],\\n 'vect__use_idf':[False],\\n 'vect__norm':[None],\\n 'clf__penalty': ['l1', 'l2'],\\n 'clf__C': [1.0, 10.0, 100.0]},\\n ]\\nlr_tfidf = Pipeline([('vect', tfidf),\\n ('clf', LogisticRegression(random_state=0))])\\ngs_lr_tfidf = GridSearchCV(lr_tfidf, param_grid,\\n scoring='accuracy',\\n cv=5,\\n verbose=1,\\n n_jobs=-1)\\ngs_lr_tfidf.fit(X_train, y_train)\\n\\nprint('Best parameter set: %s ' % gs_lr_tfidf.best_params_)\\nprint('CV Accuracy: %.3f' % gs_lr_tfidf.best_score_)\\n\\nclf = gs_lr_tfidf.best_estimator_\\nprint('Test Accuracy: %.3f' % clf.score(X_test, y_test))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"iii)<\\/h3>\\nThe points here are near the visible maxes on the 2D contour plot that have not been found yet\\n\",\"targets\":\"guess.append( [ 1.9, 0.75 ] )\\na.append(optimize.fmin(negative_posterior, guess[2], args=(x_data, y_data, sigma_meas, p_err)))\\nprint(a[2])\\ny.append(a[2][0]*numpy.ones(len(x_data)) + a[2][1]*x_data)\\n\\nguess[3] = [ 11.0, -0.6 ]\\na.append( optimize.fmin(negative_posterior, guess[3], args=(x_data, y_data, sigma_meas, p_err)) )\\nprint(a[3])\\ny.append( a[3][0]*numpy.ones(len(x_data)) + a[3][1]*x_data )\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsns.displot(data=Clustered_Users, x=\\\"Final Score\\\", hue=\\\"Is CrSk\\\", multiple=\\\"stack\\\")\\n\\nsns.displot(data=Clustered_Users, x=\\\"Total Homeworks\\\", hue=\\\"Is CrSk\\\", multiple=\\\"stack\\\")\\n\\nsns.displot(\\n data=Clustered_Users, x=\\\"Final Score\\\", hue=\\\"Is CrSk\\\", multiple=\\\"stack\\\", kind=\\\"kde\\\"\\n)\\n\\nsns.displot(\\n data=Clustered_Users, x=\\\"Total Exams\\\", hue=\\\"Is CrSk\\\", multiple=\\\"stack\\\", kind=\\\"kde\\\"\\n)\\n\\nsns.displot(\\n data=Clustered_Users, x=\\\"Letter Grade\\\", stat=\\\"percent\\\", hue=\\\"Is CrSk\\\", multiple=\\\"stack\\\"\\n)\\n\\nsns.displot(data=Clustered_Users, x=\\\"% of CrSk Sessions\\\", hue=\\\"A or Not\\\", multiple=\\\"stack\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Creating recommendations for your personal ratings\\n\\nTry with different similarity metrics (look in \\/src\\/similarity.py)\\nTry with different values of K (K is the number of neigbhours to consider when generating the recommendations)\\nWhich combination of K and number of metrics works better?, discuss it with others.\\n\",\"targets\":\"# get recommendations for a single user\\nrecommendations = recommenders.recommend_uknn(ratings, my_customer_number, K=200, similarity_metric='cosine', N=10)\\nrecommendations\\n\\n# get recommendations for a single user\\nrecommendations = recommenders.recommend_iknn(ratings, my_customer_number, K=100, similarity_metric='cosine')\\nrecommendations\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Example3DvisualizationPyNoddyAndCSV2History.ipynb\\\".\\nThe first task is:\\nCreate a history file from fault traces\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport pandas as pd\\nimport pynoddy.history\\n#Read a csv file with the vertices of the faults\\n#see notes in the bottom of the notebook for instructions on how to generate such vertices files\\ncsvfile = 'examples\\/FaultDataCSV\\/Scenario1_Vertices.csv'\\nCsvFaultData = pd.read_csv(csvfile).sort_values(['id'])\\n\\n#how much does the fault slip relative to the fault length\\nSlipParam = 0.04\\n\\n#the xyz origin of the model you will be generating\\nxy_origin=[317883,4379646, 1200-4000]\\n\\n#Get information about each parameter in Noddy format\\n#The output from the function is a dictionary with lists of the fault parameters\\nnoddyFormattedFaultData = pynoddy.history.setUpFaultRepresentation(CsvFaultData,\\n xy_origin=xy_origin, \\n SlipParam=SlipParam)\\n\\n#Create a dictionary with the stratigraphy information\\nStratDict = {}\\nStratDict['Heights'] = [2000, 2500, 3000, 3700]\\nStratDict['Names'] = ['Intrusive', 'Felsic', 'Mafic','Sed'] \\nStratDict['Density'] = [2.65, 2.5, 2.4, 2.3] \\nStratDict['MagSus'] = [0.0015, 0.0012, 0.0018, 0.001]\\n\\n#Now make the history file\\nfilename = 'sandbox\\/faultmodel.his'\\nnoddyFormattedFaultData = pynoddy.history.createPyNoddyHistoryFile(noddyFormattedFaultData, StratDict, filename=filename)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2017-02-15-jm-predict-employee-leaving.ipynb\\\".\\nThe first task is:\\nNow lets create our first hidden layer. Typically your hidden layers will use a Rectified Linear Unit(Relu) activation function in these cases, but in our case we will use an Exponential Linear Unit(Elu) activation function for its nice properties of reducing the bias shift effect on our network to have faster learning than Relu and for the fact that it acts like batch normalization without the computational complexity. We will also add the caveat of initalizing our weights and biases with a standard deviation of 0.01.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nw_1 = tf.Variable(tf.truncated_normal([num_features, 10], stddev=0.01))\\nb_1 = tf.Variable(tf.truncated_normal([10], stddev=0.01))\\n\\nlayer_1 = tf.nn.elu(tf.add(tf.matmul(X_init, w_1), b_1))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%R\\n\\ndat = results %>%\\n filter(scale==0.001, coverage<=30) %>%\\n select(rho, metric, coverage)\\n \\ndat$coverage = as.factor(dat$coverage)\\nggplot(dat, aes(x=coverage, y=rho, fill=metric)) +\\n geom_boxplot(aes(fill=metric))\\n \\n\\n%%R\\n\\n# AND AGAIN WITHOUT SUBSETTING\\ndat = results %>%\\n filter(scale==0.001) %>%\\n select(rho, metric, coverage)\\n \\ndat$coverage = as.factor(dat$coverage)\\nggplot(dat, aes(x=coverage, y=rho, fill=metric)) +\\n geom_boxplot(aes(fill=metric)) +\\n theme_bw()\\n \\n\\n%%R\\n\\ndat = subset(results, scale==0.001, select=-scale)\\nggplot(dat, aes(x=coverage, y=rho, colour=seed, linetype=metric)) +\\n geom_line() +\\n scale_x_log10()\\n\\n%%R\\nsumm = results %>%\\n filter(scale==0.001, coverage <=100) %>%\\n select(-scale) %>%\\n group_by(coverage, metric) %>%\\n summarise(rho_av=mean(rho), rho_err=sd(rho))\\n \\np = ggplot(summ, aes(x=coverage, y=rho_av, ymin=rho_av-rho_err, ymax=rho_av+rho_err, group=metric)) +\\n geom_line(aes(linetype=metric)) +\\n geom_ribbon(aes(fill=metric), alpha=0.2) +\\n xlab('Genome Coverage') +\\n ylab(expression(paste(\\\"Spearman's \\\", rho, \\\" +- SD\\\"))) +\\n #scale_x_log10()+\\n #ggtitle(\\\"Performance of WIP & IP\\\") +\\n theme_bw()\\n\\npdf(\\\"coverage-vs-rho_full.pdf\\\",width=7, height=4)\\nprint(p)\\ndev.off()\\np\\n\\n%%R\\nsumm = results %>%\\n filter(scale==0.001, coverage <= 50) %>%\\n select(-scale) %>%\\n group_by(coverage, metric) %>%\\n summarise(rho_av=mean(rho), rho_err=sd(rho))\\n \\np = ggplot(summ, aes(x=coverage, y=rho_av, ymin=rho_av-rho_err, ymax=rho_av+rho_err, group=metric)) +\\n geom_line(aes(linetype=metric)) +\\n geom_ribbon(aes(fill=metric), alpha=0.2) +\\n xlab('Genome Coverage') +\\n ylab(expression(paste(\\\"Spearman's \\\", rho, \\\" +- SD\\\"))) +\\n #scale_x_log10()+\\n #ggtitle(\\\"Performance of WIP & IP\\\") +\\n theme_bw()\\n\\npdf(\\\"coverage-vs-rho_50x.pdf\\\",width=5, height=4)\\nprint(p)\\ndev.off()\\np\\n\\n%%R\\nsem <- function(x) sqrt(var(x,na.rm=TRUE)\\/length(na.omit(x)))\\nsumm = results %>%\\n filter(scale==0.001) %>%\\n select(-scale) %>%\\n ...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nEffect of Coverage\\nHere we show the spread of data across the 100 reps as boxplots per metric and covreage level.\\nI note that the weighted product seems slightly more variable, particularly at higher coverage. Though the median is nearly always higher\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Use subplots to generate all axes objects\\nfig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(15,6))\\n# These can then be passed to multiplot, or any other obj.plot() method with the 'axes' keyword\\nnorm_cdf.label = 'Normal CDF'\\nfig = st.multiplot([brfss_weights_cdf, norm_cdf], \\n plt_kwds={'linewidth':1.5, 'title': 'Normal CDF Comparison', 'xlabel':'Weight kg'}, \\n axes=ax1)\\nnorm_cdf.label = 'Lognormal CDF'\\nfig = st.multiplot([brfss_weights_cdf, norm_cdf], \\n plt_kwds={'linewidth':1.5, 'xscale': 'log', \\n 'title': 'Lognormal CDF Comparison', 'xlabel':'log(Weight kg)'}, \\n axes=ax2)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFrom comparing the standad cdfs, difference is not so obvious, though if x is now plotted with a log scale on the x axis, the normal model fits slightly better\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Solution\\n\\nlast_pops = run_many_simulations(system, update_func2, 1000)\\nnet_changes = last_pops - p_0\\nnet_changes.describe()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUse run_many_simulations to collect the results and describe to summarize the distribution of net changes.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Change the order that the colors are chosen\\nChange orientation to horizontal\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\np = sns.violinplot(data=df,\\n y = 'Category',\\n x = 'Duration',\\n order = sorted(df.Category.unique()),\\n orient=\\\"h\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Cost of Householder factorization\\nThe dominant cost comes from the line\\nPython\\n R[i:,i:] -= 2 * numpy.outer(v, v.dot(R[i:,i:]))\\nwere R[i:,i:] is an $(m-i)\\\\times(n-i)$ matrix.\\nThis line performs $2(m-i)(n-i)$ operations in v.dot(R[i:,i:]), another $(m-i)(n-i)$ in the \\\"outer\\\" product and again in subtraction. As written, multiplication by 2 would be another $(m-i)(n-i)$ operations, but is only $m-i$ operations if we rewrite as\\nPython\\n w = 2*v\\n R[i:,i:] -= numpy.outer(w, v.dot(R[i:,i:]))\\nin which case the leading order cost is $4(m-i)(n-i)$. To compute the total cost, we need to sum over all columns $i$,\\n$$\\\\begin{split} \\\\sum_{i=1}^n 4(m-i)(n-i) &= 4 \\\\Big[ \\\\sum_{i=1}^n (m-n)(n-i) + \\\\sum_{i=1}^n (n-i)^2 \\\\Big] \\\\\\n&= 4 (m-n) \\\\sum_{i=1}^n i + 4 \\\\sum_{i=1}^n i^2 \\\\\\n&\\\\approx 2 (m-n) n^2 + 4 n^3\\/3 \\\\\\n&= 2 m n^2 - \\\\frac 2 3 n^3 .\\n\\\\end{split}$$\\nRecall that Gram-Schmidt QR cost $2 m n^2$, so Householder costs about the same when $m \\\\gg n$ and is markedly less expensive when $m \\\\approx n$.\\nLeast squares and the normal equations\\nA least squares problem takes the form: given an $m\\\\times n$ matrix $A$ ($m \\\\ge n$), find $x$ such that\\n$$ \\\\lVert Ax - b \\\\rVert $$\\nis minimized. If $A$ is square and full rank, then this minimizer will satisfy $A x - b = 0$, but that is not the case in general because $b$ is not in the range of $A$.\\nThe residual $A x - b$ must be orthogonal to the range of $A$.\\n\\nIs this the same as saying $A^T (A x - b) = 0$?\\nIf $QR = A$, is it the same as $Q^T (A x - b) = 0$?\\n\\nIn HW2, we showed that $QQ^T$ is an orthogonal projector onto the range of $Q$. If $QR = A$,\\n$$ QQ^T (A x - b) = QQ^T(Q R x - b) = Q (Q^T Q) R x - QQ^T b = QR x - QQ^T b = A x - QQ^T b . $$\\nSo if $b$ is in the range of $A$, we can solve $A x = b$. If not, we need only orthogonally project $b$ into the range of $A$.\\nSolution by QR (Householder)\\nSolve $R x = Q^T b$.\\n\\nQR factorization costs $2 m n^2 - \\\\frac 2 3 n^3$ operations and is done once per matrix $A$.\\nComputing $Q^T b$ costs $4 (m-n)n + 2 n^2 = 4 mn - 2n^2$ (using the...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Test accuracy of solver for an ill-conditioned square matrix\\n\\nx = numpy.linspace(-1,1,19)\\nA = numpy.vander(x)\\nprint('cond(A) = ',numpy.linalg.cond(A))\\nQ, R = numpy.linalg.qr(A)\\nprint('cond(R^{-1} Q^T A) =', numpy.linalg.cond(numpy.linalg.solve(R, Q.T.dot(A))))\\nL = numpy.linalg.cholesky(A.T.dot(A))\\nprint('cond(L^{-T} L^{-1} A^T A) =', numpy.linalg.cond(numpy.linalg.solve(L.T, numpy.linalg.solve(L, A.T.dot(A)))))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Notebooks\\/Sistema_Binario-Evolucion_Temporal_y_observaciones_HyT.ipynb\\\".\\nThe first task is:\\nAhora graficamos $a$ en términos de $e$, tanto para la solución analítica como numérica\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfig,eje= plt.subplots(1,1,figsize=(5,5))\\neje.plot(e,at*R_ast, label=u'sol. numérica')\\nee = np.linspace(min(e),e0,10)\\na_an = a0_m*g(ee)\\/g(e0)\\neje.plot(ee,a_an,'o',label=u'sol. analítica')\\neje.set_title(u'Semieje mayor v\\/s excentricidad',fontsize=14)\\neje.set_xlabel(r'$e$',fontsize=15)\\neje.set_ylabel(r'$a$',fontsize=15)\\nplt.legend(loc='best')\\nplt.grid()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Aperture location sanity check by visual inspection\\nArbitrarily choose the first G FITS file\\n\",\"targets\":\"fits_file = fits_files[5]\\nprint(fits_file)\\nhdus = fits.open(os.path.join(fits_root, fits_file))\\nimage_data = hdus[data_index].data\\n\\nmedian = np.median(image_data)\\nshow_image(image_data, position_map, measurement_aperture, annotate=True, vmin=10, vmax=median*4)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"But since myHDL implements 2's complement, we need to test for negative numbers where the leading bit is the signed signal\\n\",\"targets\":\"TestNegNum=-26\\nprint(f\\\"\\\"\\\"Target: {TestNegNum}\\nAbsolote Bin: {bin(abs(TestNegNum), 8)}, \\nSigned Bin: {bin(TestNegNum, 8)}\\\"\\\"\\\")\\n\\nTestNegNumBV=intbv(TestNegNum)[8:]\\nTestNegNumBV, TestNegNumBV.signed()\\n\\nR=-R; I=-I\\nprint(f'Re: {R}, Im: {I}')\\n\\nRN=intbv(R, min=ReMin, max=ReMax); RN\\nRNBin=''.join([str(int(i)) for i in RN])\\nRN.signed(), bin(R, ReWordLen), RNBin, bin(R, ReWordLen)==RNBin\\n\\nIN=intbv(I, min=ImMin, max=ImMax); IN\\nINBin=''.join([str(int(i)) for i in IN])\\nIN.signed(), bin(I, ImWordLen), INBin, bin(I, ImWordLen)==INBin\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Produce learning curves for varying training set sizes and maximum depths\\nvs.ModelLearning(features, prices)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nBenefit of splitting the data set into Training and Testing sets\\nWithout testing our model, we would not know if the model is suffering from high bias or high variance, ie, we won't know if the model is very simple or very complex. By very simple, I mean, having fewer features than needed or having fewer nonlinear terms. By very complex or high variance, I mean having many features than needed or having many nonlinear terms in the model. Without having test data, we will go on making the model more and more complex just to decrease the training error. \\n\\nAnalyzing Model Performance\\nLearning Curves\\nThe following code cell produces four graphs for a decision tree model with different maximum depths. Each graph visualizes the learning curves of the model for both training and testing as the size of the training set is increased. Note that the shaded reigon of a learning curve denotes the uncertainty of that curve (measured as the standard deviation). The model is scored on both the training and testing sets using R^{2<\\/sup>, the coefficient of determination.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.14\\/_downloads\\/plot_introduction.ipynb\\\".\\nThe first task is:\\nLook at the channels in raw:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(raw.ch_names)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Datasets\\nnoisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure = load_extra_datasets()\\n\\ndatasets = {\\\"noisy_circles\\\": noisy_circles,\\n \\\"noisy_moons\\\": noisy_moons,\\n \\\"blobs\\\": blobs,\\n \\\"gaussian_quantiles\\\": gaussian_quantiles}\\n\\n### START CODE HERE ### (choose your dataset)\\ndataset = \\\"gaussian_quantiles\\\"\\n### END CODE HERE ###\\n\\nX, Y = datasets[dataset]\\nX, Y = X.T, Y.reshape(1, Y.shape[0])\\n\\n# make blobs binary\\nif dataset == \\\"blobs\\\":\\n Y = Y%2\\n\\n# Visualize the data\\nplt.scatter(X[0, :], X[1, :], c=Y, s=40, cmap=plt.cm.Spectral);\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nInterpretation:\\n- The larger models (with more hidden units) are able to fit the training set better, until eventually the largest models overfit the data. \\n- The best hidden layer size seems to be around n_h = 5. Indeed, a value around here seems to fits the data well without also incurring noticable overfitting.\\n- You will also learn later about regularization, which lets you use very large models (such as n_h = 50) without much overfitting. \\nOptional questions:\\nNote: Remember to submit the assignment but clicking the blue \\\"Submit Assignment\\\" button at the upper-right. \\nSome optional\\/ungraded questions that you can explore if you wish: \\n- What happens when you change the tanh activation for a sigmoid activation or a ReLU activation?\\n- Play with the learning_rate. What happens?\\n- What if we change the dataset? (See part 5 below!)\\n\\nYou've learnt to:\\n- Build a complete neural network with a hidden layer\\n- Make a good use of a non-linear unit\\n- Implemented forward propagation and backpropagation, and trained a neural network\\n- See the impact of varying the hidden layer size, including overfitting.\\nNice work! \\n5) Performance on other datasets\\nIf you want, you can rerun the whole notebook (minus the dataset part) for each of the following datasets.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"And let's give our model a descriptive title.\\n\",\"targets\":\"m.title = \\\"MTC Example 1 (Simple MNL)\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Computer Number Systems\\nDecimal to Binary\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef DecimialtoBaseN(dec, base):\\n quotant=[dec]; remander=[]\\n while True:\\n q, r=np.divmod(quotant[-1], base)\\n quotant.append(q); remander.append(r)\\n if q==0: break\\n \\n TwosProd=[]\\n for i in range(len(remander)):\\n TwosProd.append(remander[i]*base**i)\\n return quotant, remander, TwosProd[::-1], np.sum(TwosProd)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create the feature columns\\nNext, we define the feature columns\\nExercise 3\\nThere are different ways to set up the feature columns for our model. \\nIn the first TODO below, you are asked to create a function get_categorical which takes a feature name and its potential values and returns an indicator tf.feature_column based on a categorical with vocabulary list column. Look back at the documentation for tf.feature_column.indicator_column to ensure you call the arguments correctly.\\nIn the next TODO, you are asked to complete the code to create a function called get_cols. It has no argumnets but should return a list of all the tf.feature_columns you intend to use for your model. Hint: use the get_categorical function you created above to make your code easier to read.\\n\",\"targets\":\"def get_categorical(name, values):\\n return # TODO: Your code goes here\\n\\ndef get_cols():\\n # Define column types\\n return # TODO: Your code goes here\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Comparing with Day of Week\\n\",\"targets\":\"dayofweek = pd.DatetimeIndex(pivoted.columns).dayofweek\\n\\nplt.scatter(X2[:, 0], X2[:, 1], c=dayofweek, cmap='rainbow')\\nplt.colorbar();\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\".... Wait, only 9? Out of the total number of battles Robb Stark fought, he was successful as a attacker but not great on the defensive. Overall, winning 9 out of 24 battles is really not that impressive.\\nPerhaps 'The Young Wolf' wasn't as impressive as we thought...\\nTry answering some more questions:\\n\\nWhat was the average size of Robb Stark's armies against those defending against him?\\nHow did the Lanninster\\/Baratheons fare in the War of the Five Kings? \\nWhich king had the highest winning percentages? (Requires some light statistics...)\\nWho was the most effective commander (there are several to choose from)?\\n\\nTry some other methods as well in Pandas:\\n\\n.mean() - gives you the average of some value (you have to designate the key-value in some cases)\\n.median() - returns the median value of an object\\n.min() - gives you the lowest value in that array\\n.fillna(0.0).astype(int) - this is a way to get rid of all the float objects in your dataset. \\n.describe() - gives you an overview of the object's data, according to counts, unique values, and data types\\n\\nNow that you have a light understanding of how data analysis is done, let's create some visualizations!\\nCreating Data Visualizations in Python\\nRelying a lot on Matplotlib here, data visualizations allow us to better communicate and understand the information we're able to create through our analyses.\\nLet's try to do a few based on the questions we've already resolved so far. Let's create some bar graphs.\\nFirst, let's create a new object robb_off_viz that measures what's going on in our robb_off object, using two more methods:\\n* .groupby() - calculating the unique values in a particular key\\n* .len() - measuring them by their \\\"length\\\" or number of rows\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nrobb_off_viz = robb_off.groupby('attacker_outcome').apply(len)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# The function for training the model\\n\\nLOSS_SGD = []\\nw = torch.tensor(-15.0, requires_grad = True)\\nb = torch.tensor(-10.0, requires_grad = True)\\n\\ndef train_model_SGD(iter):\\n \\n # Loop\\n for epoch in range(iter):\\n \\n # SGD is an approximation of out true total loss\\/cost, in this line of code we calculate our true loss\\/cost and store it\\n Yhat = forward(X)\\n\\n # store the loss \\n LOSS_SGD.append(criterion(Yhat, Y).tolist())\\n \\n for x, y in zip(X, Y):\\n \\n # make a pridiction\\n yhat = forward(x)\\n \\n # calculate the loss \\n loss = criterion(yhat, y)\\n\\n # Section for plotting\\n get_surface.set_para_loss(w.data.tolist(), b.data.tolist(), loss.tolist())\\n \\n # backward pass: compute gradient of the loss with respect to all the learnable parameters\\n loss.backward()\\n \\n # update parameters slope and bias\\n w.data = w.data - lr * w.grad.data\\n b.data = b.data - lr * b.grad.data\\n\\n # zero the gradients before running the backward pass\\n w.grad.data.zero_()\\n b.grad.data.zero_()\\n \\n #plot surface and data space after each epoch \\n get_surface.plot_ps()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nDefine train_model_SGD<\\/code> function for training the model.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapter 5 - Functions and Files.ipynb\\\".\\nThe first task is:\\nWe can also have a function return multiple values by combining them in a tuple (the type of ordered, immutable list we talked about in the previous chapter!). Python has a nice way of 'unpacking' such a tuple using assignment:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef count(text):\\n words = text.split(\\\" \\\")\\n word_count = len(words)\\n character_count = len(text)\\n return word_count, character_count\\n\\nword_count, character_count = count(\\\"To be or not to be , that is the question .\\\")\\nprint(word_count)\\nprint(character_count)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create a Cloud Storage bucket\\nThe following steps are required, regardless of your notebook environment.\\nSet the name of your Cloud Storage bucket below. It must be unique across all\\nCloud Storage buckets.\\nYou may also change the REGION variable, which is used for operations\\nthroughout the rest of this notebook. Make sure to choose a region where Vertex AI services are\\navailable. You may\\nnot use a Multi-Regional Storage bucket for training with Vertex AI.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nBUCKET_URI = \\\"gs:\\/\\/[your-bucket-name]\\\" # @param {type:\\\"string\\\"}\\nREGION = \\\"[your-region]\\\" # @param {type:\\\"string\\\"}\\n\\nif BUCKET_URI == \\\"\\\" or BUCKET_URI is None or BUCKET_URI == \\\"gs:\\/\\/[your-bucket-name]\\\":\\n BUCKET_URI = \\\"gs:\\/\\/\\\" + PROJECT_ID + \\\"aip-\\\" + TIMESTAMP\\n\\nif REGION == \\\"[your-region]\\\":\\n REGION = \\\"us-central1\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!pncaqsraw4pnceval.py -O --timeresolution=daily \\\\\\n --start-date 2013-05-01 --end-date 2013-07-01 \\\\\\n --wktpolygon \\\"POLYGON ((-181.25 0, 178.75 0, 178.75 90, -181.25 90, -181.25 0))\\\"\\n\\n%ls -l AQS_DATA_20130501-20130701.nc\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCHECK POINT\\nWhat should the bounding box be as a WKT Polygon?\\nANSWERS Hidden\\n}\\n\\n\\\"POLYGON ((llcrnrlon llcrnrlat, lrcrnrlon lrcrnrlat, urcrnrlon urcrnrlat, ulcrnrlon ulcrnrlat, llcrnrlon llcrnrlat))\\\"\\n\\n<\\/div>\\n\\nDownload and Process\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# call the pandas DataFrame row-by-row iterator, which\\n# iterates through the index, and columns\\nG = nx.DiGraph()\\nfor n, d in stations.iterrows(): \\n G.add_node(n, attr_dict = d.to_dict())\\n \\n# use groupby to retrieve the pair of nodes and the data count\\nfor (start, stop), d in trips.groupby(['from_station_id', 'to_station_id']):\\n G.add_edge(start, stop, count = len(d))\\n\\n# notice that there're self-loops\\nprint(G.edges(data = True)[:4])\\nprint()\\n\\n# examine the density (the proportion of nodes that are connected)\\nnum_edges = len(G.edges())\\nnum_possible_edges = len(G.nodes()) ** 2\\ndensity = num_edges \\/ num_possible_edges\\nprint('density:', density)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAt this point, we have our stations and trips data loaded into memory. \\nHow we construct the graph depends on the kind of questions we want to answer, which makes the definition of the \\\"unit of consideration\\\" (or the entities for which we are trying to model their relationships) is extremely important. \\nLet's try to answer the question: \\\"What are the most popular trip paths?\\\" In this case, the bike station is a reasonable \\\"unit of consideration\\\", so we will use the bike stations as the nodes. \\nTo start, we'll initialize an directed graph G and add in the nodes and edges.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# EXERCICIO\\npluralLambdaRDD = palavrasRDD.map(lambda x: x+'s')\\nprint pluralLambdaRDD.collect()\\n\\nassert pluralLambdaRDD.collect()==['gatos','elefantes','ratos','ratos','gatos'], 'valores incorretos!'\\nprint 'OK'\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNota: utilize o comando collect() apenas quando tiver certeza de que a lista caberá na memória. Para gravar os resultados de volta em arquivo texto ou base de dados utilizaremos outro comando.\\n (1d) Utilizando uma função lambda \\nRepita a criação de um RDD de plurais, porém utilizando uma função lambda.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"! curl -X POST\\n-H \\\"Authorization: Bearer \\\"$(gcloud auth application-default print-access-token) \\n-H \\\"Content-Type: application\\/json; charset=utf-8\\\" \\n-d @request.json \\n$CLOUD_FUNCTION_URL\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nMake the prediction request\\nTODO\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"APS5_alunos.ipynb\\\".\\nThe first task is:\\nQ6 - Tirando conclusões com base nos dados\\nEm um certo lugar já ocorreram abalos com Magnitude Type MB e Type Nuclear Explosion. \\nResponda: \\n * É mais provável que tenha sido no norte ou no sul? \\nAssuma que os Magnitude Type e Type são independentes\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf.loc[(df.Type==\\\"Nuclear Explosion\\\")&(df[\\\"Magnitude Type\\\"]==\\\"MB\\\")&(df[\\\"Hemisfério\\\"]==\\\"Sul\\\"),\\\"Hemis\\\"]=\\\"Sul\\\"\\ndf.loc[(df.Type==\\\"Nuclear Explosion\\\")&(df[\\\"Magnitude Type\\\"]==\\\"MB\\\")&(df[\\\"Hemisfério\\\"]==\\\"Norte\\\"),\\\"Hemis\\\"]=\\\"Norte\\\"\\nsul=df[\\\"Hemis\\\"].value_counts(\\\"Sul\\\")\\nsul\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"L3 - Preprocessing.ipynb\\\".\\nThe first task is:\\nFinding and Handling Missing Data\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# find rows that Price is null\\ndf[pd.isnull(df['Price'])]\\n\\nindex_with_null = df[pd.isnull(df['Price'])].index\\nindex_with_null\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Data Pre-Processing & Feature Selection.ipynb\\\".\\nThe first task is:\\nDrop the highest VIF features and print the high collinearity columns in a list\\nCan you write Python code for it?\\n\",\"targets\":\"\\nhigh_collinearity_columns = vif_df.feature[vif_df['vif'] >= 10].to_list()\\n\\nhigh_collinearity_columns\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Produto\\nprodutoZ = z1*z2\\nprodutoZ = produtoZ.expand() # Expandindo Multiplicação\\nprodutoZ = produtoZ.collect(I) # Agrupando termos\\ndisplay(Math(\\\"z_1 z_2 = \\\"+ latex(produtoZ)))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nA4 Multiplicação\\n$$z_1 z_2 = (a+bi)(c+di)$$\\nAplicando a distribuição da multiplicação\\n$$z_1 z_2 = ac+adi + bci + dci^2$$\\nAgrupando os termos e dado que $i^2 =-1$:\\n$$z_1 z_2 = (ac -dc) + (ad + bc)i$$\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Removing missing values from a list\\n\\ncountries_asia = [\\\"Afghanistan\\\",\\\"\\\",\\\"Bhutan\\\",\\\"\\\",\\\"China\\\",\\\"\\\",\\\"Georgia\\\",\\\"\\\",\\\"\\\",\\\"India\\\"]\\n[country for country in countries_asia if country!=\\\"\\\"]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nList Comprehensions vs Filter function\\nWe used the filter function to remove the missing values from a list of Asian countries. Let's use list comprehensions to get the same results.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Assessing Global Spatial Autocorrelation\\nWe calculate Moran's I. A test for global autocorrelation for a continuous attribute.\\n\",\"targets\":\"from pysal.explore.esda.moran import Moran\\n\\nw = Queen.from_dataframe(gdf)\\nmoran = Moran(y, w)\\nmoran.I\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1.2B) Why does the diagonal from top left to bottom right have such strong correlations?\\n1.2C) Which features correlate the most? Which features correlate the least?\\n1.2D) Which features do you think will be most useful for predicting life expectancy? Why?\\n1.2E) Do any features (life expectancy is not counted as a feature) correlate strongly with each other?\\n1.2F) If two features correlate very strongly with each other, would you want to include them both in your analysis? Why or why not?\\n1.2G) Using your answers for 1.2C - 1.2F, fill in the code box below with a filtered list of statistical variables that you think are best to use for our model. The code box will generate a new dataframe containing only our selected useful features.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfiltered_stat_vars_to_query = [\\n \\\"LifeExpectancy_Person\\\",\\n \\\"Count_Person\\\",\\n \\\"Count_Person_MarriedAndNotSeparated\\\",\\n \\\"Median_Income_Person\\\",\\n \\\"Count_Household_With4OrMorePerson\\\"\\n \\n]\\n\\n# Get data from Data Commons\\nfiltered_df = dcp.build_multivariate_dataframe(county_dcids, stat_vars_to_query)\\ndisplay(filtered_df)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#your turn\\nfrom sklearn.decomposition import PCA\\n\\n\\ncluster = KMeans(n_clusters=5)\\nx_cols['cluster'] = cluster.fit_predict(x_cols[x_cols.columns[1:]])\\n\\npca = PCA(n_components=2)\\nx_cols['x'] = pca.fit_transform(x_cols[x_cols.columns[1:]])[:,0]\\nx_cols['y'] = pca.fit_transform(x_cols[x_cols.columns[1:]])[:,1]\\n\\n\\ncustomer_clusters = x_cols[['customer_name', 'cluster', 'x', 'y']]\\ndf = pd.merge(df_transactions, customer_clusters)\\ndf = pd.merge(df_offers, df)\\n\\nsns.lmplot('x', 'y',\\n data=df,\\n fit_reg=False,\\n hue=\\\"cluster\\\", \\n scatter_kws={\\\"marker\\\": \\\"D\\\",\\n \\\"s\\\": 100})\\nplt.title('Scatter plot of clustered data')\\n\\n\\n\\ndf['is_4'] = df.cluster==4\\nprint(df.groupby(\\\"is_4\\\")[['min_qty', 'discount']].mean())\\ndf.groupby(\\\"is_4\\\").varietal.value_counts()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nChoosing $K$: The Gap Statistic\\nThere is one last method worth covering for picking $K$, the so-called Gap statistic. The computation for the gap statistic builds on the sum-of-squares established in the Elbow method discussion, and compares it to the sum-of-squares of a \\\"null distribution,\\\" that is, a random set of points with no clustering. The estimate for the optimal number of clusters $K$ is the value for which $\\\\log{SS}$ falls the farthest below that of the reference distribution:\\n$$G_k = E_n^*{\\\\log SS_k} - \\\\log SS_k$$\\nIn other words a good clustering yields a much larger difference between the reference distribution and the clustered data. The reference distribution is a Monte Carlo (randomization) procedure that constructs $B$ random distributions of points within the bounding box (limits) of the original data and then applies K-means to this synthetic distribution of data points.. $E_n^*{\\\\log SS_k}$ is just the average $SS_k$ over all $B$ replicates. We then compute the standard deviation $\\\\sigma_{SS}$ of the values of $SS_k$ computed from the $B$ replicates of the reference distribution and compute\\n$$s_k = \\\\sqrt{1+1\\/B}\\\\sigma_{SS}$$\\nFinally, we choose $K=k$ such that $G_k \\\\geq G_{k+1} - s_{k+1}$.\\nAside: Choosing $K$ when we Have Labels\\nUnsupervised learning expects that we do not have the labels. In some situations, we may wish to cluster data that is labeled. Computing the optimal number of clusters is much easier if we have access to labels. There are several methods available. We will not go into the math or details since it is rare to have access to the labels, but we provide the names and references of these measures.\\n\\nAdjusted Rand Index\\nMutual Information\\nV-Measure\\nFowlkes–Mallows index\\n\\nSee this article for more information about these metrics.\\nVisualizing Clusters using PCA\\nHow do we visualize clusters? If we only had two features, we could likely plot the data as is. But we have 100 data points each containing 32 features (dimensions). Principal Component Analysis (PCA) will help us reduce...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Gets all measurement sites contained in Tar Creek \\ntar_creek_site = 'epaSuperfundSiteId\\/OKD980629844' # DCID of Tar Creek\\nmeasurement_sites = dc.get_places_in([tar_creek_site], 'SuperfundMeasurementSite')[tar_creek_site]\\n\\n# Gets stats for contaminant variables for said measurement sites\\ntar_creek_df = dcpd.build_multivariate_dataframe(\\n measurement_sites,\\n [\\n 'Concentration_Cadmium_BodyOfWater_GroundWater',\\n 'Concentration_DissolvedContaminant_Cadmium_BodyOfWater_GroundWater',\\n 'Concentration_DissolvedContaminant_Iron_BodyOfWater_GroundWater',\\n 'Concentration_DissolvedContaminant_Lead_BodyOfWater_GroundWater',\\n 'Concentration_DissolvedContaminant_Zinc_BodyOfWater_GroundWater',\\n 'Concentration_Iron_BodyOfWater_GroundWater',\\n 'Concentration_Lead_BodyOfWater_GroundWater',\\n 'Concentration_Sulfate_BodyOfWater_GroundWater',\\n 'DissolvedOxygen_BodyOfWater_GroundWater',\\n 'Concentration_Zinc_BodyOfWater_GroundWater',\\n 'PotentialOfHydrogen_BodyOfWater_GroundWater',\\n 'ElectricalConductivity_BodyOfWater_GroundWater',\\n 'Temperature_BodyOfWater_GroundWater',\\n 'WaterHardness_BodyOfWater_GroundWater'\\n ])\\n\\ntar_creek_df.head()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAdditional statistics for Tar Creek site\\nTar Creek is one of the largest Superfund sites, and only for that site we have additional stats on contaminants in the ground water from sampling wells. These stats are attached to instances of SuperfundMeasurementSite contained in Tar Creek.\\nThe measurement sites are listed on the Tar Creek Graph Browser page, and a measurement site's Graph Browser page (example) lists all available statistical variables.\\nTo get these stats, list the measurement sites within Tar Creek, and then provide all associated variables, as follows:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"MPI\\/ipyparallel_mpi_tests.ipynb\\\".\\nThe first task is:\\nConfigure mpi profile first:\\n - http:\\/\\/ipyparallel.readthedocs.io\\/en\\/latest\\/process.html#parallel-process\\nCan you write Python code for it?\\n\",\"targets\":\"\\nc = ipp.Client(profile='mpi')\\n\\nc.ids\\n\\nc[:].apply_sync(lambda : \\\"Hello, World\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Linear model with no bias\\nw_LS, resid, rank, s = np.linalg.lstsq(X_train, s_train)\\ns_hat_test = X_test.dot(w_LS)\\nprint('Test MSE for linear model without bias:', square_error(s_test, s_hat_test))\\n\\n# Linear model with no bias\\nZ_train = np.hstack((np.ones((X_train.shape[0],1)), X_train))\\nZ_test = np.hstack((np.ones((X_test.shape[0],1)), X_test))\\n\\nw_LS, resid, rank, s = np.linalg.lstsq(Z_train, s_train)\\ns_hat_test = Z_test.dot(w_LS)\\nprint('Test MSE for linear model with bias:', square_error(s_test, s_hat_test))\\n\\n# Polynomial model degree 2\\nZ_train = np.hstack((np.ones((X_train.shape[0],1)), X_train, X_train**2))\\nZ_test = np.hstack((np.ones((X_test.shape[0],1)), X_test, X_test**2))\\n\\nw_LS, resid, rank, s = np.linalg.lstsq(Z_train, s_train)\\ns_hat_test = Z_test.dot(w_LS)\\nprint('Test MSE for polynomial model (order 2):', square_error(s_test, s_hat_test))\\n\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIt may seem that increasing the degree of the polynomia is always beneficial, as we can implement a more expressive function. A polynomia of degree $M$ would include all polynomia of lower degrees as particular cases. However, if we increase the number of parameters without control, the polynomia would eventually get expressive enough to adjust any given set of training points to arbitrary precision, what does not necessarily mean that the solution is obtaining a model that can be extrapolated to new data.\\nThe conclusions is that, when adjusting a parametric model using least squares, we need to validate the model, for which we can use the cross-validation techniques we introudece in Section 7. In this contexts, validating the model implies:\\n - Validating the kind of model that will be used, e.g., linear, polynomial, logarithmic, etc ... \\n - Validating any additional parameters that the nodel may have, e.g., if selecting a polynomial model, the degree of the polynomia.\\nThe code below shows the performance of different models. However, no validation process is considered, so the reported test MSEs could not be used as criteria to select the best model.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Conclusion\\nWe now have a good method of combining contiguous events from INPUTEVENTS_MV. Note that this is usually not required, as the linkorderid is meant to partition these events for us. For example, lets look at a very common sedative agent used in the ICU, propofol:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint(\\\"Durations from INPUTEVENTS for one patient given propofol...\\\")\\nquery = query_schema + \\\"\\\"\\\"\\nwith t1 as\\n(\\nselect icustay_id\\n , di.label\\n , mv.linkorderid, mv.orderid\\n , starttime\\n , endtime\\n , rate, rateuom\\n , amount, amountuom\\nfrom inputevents_mv mv\\ninner join d_items di\\non mv.itemid = di.itemid\\nand statusdescription != 'Rewritten'\\n\\\"\\\"\\\" + query_where_clause + \\\"\\\"\\\"\\nand mv.itemid = 222168\\n)\\nselect \\n label\\n , linkorderid, orderid\\n , starttime\\n , endtime\\n , rate, rateuom\\n , amount, amountuom\\nfrom t1\\norder by starttime, endtime\\n\\\"\\\"\\\"\\nie = pd.read_sql_query(query,con)\\n\\ndisplay_df(ie)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# TODO 1a - Your code here\\n\\n\\n\\n# TODO 1b - Your code here\\n\\n\\n\\n# TODO 1c - Your code here\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nImprove Model Performance Using Feature Engineering\\nWe now improve our model's performance by creating the following feature engineering types: Temporal, Categorical, and Geolocation. \\nTemporal Feature Columns\\nLab Task #1: Processing temporal feature columns in Keras\\nWe incorporate the temporal feature pickup_datetime. As noted earlier, pickup_datetime is a string and we will need to handle this within the model. First, you will include the pickup_datetime as a feature and then you will need to modify the model to handle our string feature.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create another entity with relationship to the \\\"clicks\\\" table\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n'''\\nes = es.entity_from_dataframe(\\n entity_id='users',\\n dataframe=df_users,\\n index='id')\\n\\nnew_relationship = ft.Relationship(\\n es[\\\"users\\\"][\\\"id\\\"],\\n es[\\\"clicks\\\"][\\\"user_id\\\"])\\n\\nes = es.add_relationship(new_relationship)\\n'''\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Additional features worth having a look at\\n* conda integration (--use-conda flag)\\n* test runs (--dryrun)\\n* print shell commands (-p)\\n* includes of other Snakefiles\\n* configuration files\\n* rulegraph (--rulegraph)\\n* remote files (e.g. Amazon Simple Storage Service, Google Cloud Storage, SSH, HTTP, FTP, Dopbox, WebDAV, ...)\\n* snakemake documentation and FAQ\\nUtilizing Snakemake for Data Analysis\\nThe electrophysiology analysis toolkit\\n\\nWe will present a simple data analysis workflow based on a published dataset of complex electrophysiology data using the electrophysiology analysis toolkit Elephant. Elephant provides a number of methods for spiketrain and LFP analysis. Elephant contains a number of methods focussing on analysis of higher order correlation in spiking activity and the statistical evaluation of these. Elephant is based on the Neo data framework, which we will first introduce based on artificially generated spiking data with a known correlation.\\nNeo - the data framework \\n\\nNeo provides a set of classes for representing time series data (SpikeTrain, AnalogSignalArray, etc.), for representing the hierarchical arrangement of data in an experiment (Segment, Block) and for representing the relationship between spike trains and recording channels (ChannelIndex, Unit). Neo is used by a number of data visualization tools (OpenElectrophy, SpykeViewer) and by the PyNN metasimulator. Neo offers reading capabilities for a large number of proprietary electrophysiology data formats and conversion capability to generic open source data formats\\/models.\\n\\nThe Neo data model consists of container (Block, Segment, ChannelIndex, Unit) and data objects (AnalogSignals, SpikeTrain, Epoch, Events). Container objects provide the...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# imports for data handling and visualization\\nfrom quantities import Hz, ms\\nfrom elephant.spike_train_generation import homogeneous_poisson_process, compound_poisson_process\\nimport neo\\nimport numpy as np\\nimport matplotlib.pyplot as plt\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Apply the spatial filter\\nThe spatial filter can be applied to different data types: raw, epochs,\\nevoked data or the data covariance matrix to gain a static image of power.\\nThe function to apply the spatial filter to :class:~mne.Evoked data is\\n:func:~mne.beamformer.apply_lcmv which is\\nwhat we will use here. The other functions are\\n:func:~mne.beamformer.apply_lcmv_raw,\\n:func:~mne.beamformer.apply_lcmv_epochs, and\\n:func:~mne.beamformer.apply_lcmv_cov.\\n\",\"targets\":\"stc = apply_lcmv(evoked, filters)\\nstc_vec = apply_lcmv(evoked, filters_vec)\\ndel filters, filters_vec\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2-Rad_s_datotekama.ipynb\\\".\\nThe first task is:\\n2.2. Pisanje datoteke\\nKada želimo nešto zapisati u datoteku, potrebno je datoteku otvoriti funkcijom open(). Prvi argument sadrži naziv datoteke u koju ćemo zapisati željeni sadržaj. Drugi argument sadrži vrijednost w. Ako već postoji datoteka s nazivom iz prvog argumenta, postojeći podaci će biti obrisani, a novi će biti zapisani. U slučaju ako datoteka s nazivom iz prvog argumenta ne postoji, stvorit će se nova datoteka s tim nazivom. To ćemo pridružiti varijabli npr. f.\\nZatim ćemo nad varijablom f pokretati metodu write(). Metoda write() prima kao argument niz znakova koji želimo zapisati u datoteku. Možemo pokrenuti više metoda write() uzastopno.\\nKonačno, nakon što završimo zapisivanje u datoteku, obavezno trebamo datoteku i zatvoriti metodom close(). Time dajemo uputu da više nećemo pristupati datoteci i u nju zapisivati. Nakon metode close() nije više moguće pisanje u datoteku.\\nNa sljedeći način ćemo pohraniti niz znakova u novu datoteku datoteka.txt:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nf=open('datoteka.txt','w')\\nf.write('Ovo je prvi red.')\\nf.write('Je li ovo drugi red?\\\\nOvo je 2. red.')\\nf.write('\\\\nOvo je 3. red.')\\nf.close()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"A more complicated function\\nand its derivative\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef g(x, m=np):\\n y = x\\n for i in range(2):\\n # a = m.log(y)\\n # b = y ** m.pi\\n # c = m.cos(b)\\n # y = c * a\\n y = m.cos(y**m.pi) * m.log(y)\\n return y\\n\\ngexpr = g(x, m=sympy)\\ngexpr\\n\\nsympy.diff(gexpr, x)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%timeit\\nfrom math import fabs\\n\\n\\ndef laplace_grid_python(n, top, bottom, left, right, tol, iter_max):\\n \\n # initialize\\n phi = np.zeros((n+1, n+1))\\n iters = 0 # number of iterations\\n err_max = 1e6 # maximum error in grid (start at some arbitrary number just to enter loop)\\n\\n # set boundary conditions\\n phi[0, :] = bottom\\n phi[-1, :] = top\\n phi[:, 0] = left\\n phi[:, -1] = right\\n \\n # run while loop until tolerance reached or max iterations\\n while (err_max > tol and iters < iter_max):\\n \\n # reset the maximum error to something small (I suggest something like -1)\\n err_max = -1.0\\n\\n # loop over all interior cells\\n for i in range(1, n):\\n for j in range(1, n):\\n\\n # save previous point\\n phi_prev = phi[i, j]\\n \\n # update point\\n phi[i, j] = (phi[i-1,j] + phi[i+1,j] + phi[i,j-1] + phi[i,j+1])\\/4.0\\n \\n # update maximum error\\n err_max = max(err_max, fabs(phi[i, j] - phi_prev))\\n\\n # update iteration count\\n iters += 1\\n\\n return phi, err_max, iters\\n\\n# run a sample case (50 x 50 grid with bottom and left and 1.0, top and right at 0.0)\\nn = 50\\ntop = 0.0\\nbottom = 1.0\\nleft = 1.0\\nright = 0.0\\ntol = 1e-5\\niter_max = 10000\\n\\nphi, err_max, iters = laplace_grid_python(n, top, bottom, left, right, tol, iter_max)\\n\\n# plot it\\nx = np.linspace(0, 1, n+1)\\ny = np.linspace(0, 1, n+1)\\n[X, Y] = np.meshgrid(x, y)\\n\\nplt.figure()\\nplt.contourf(X, Y, phi, 100, cmap=plt.cm.get_cmap(\\\"YlGnBu\\\"))\\nplt.colorbar()\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIn our implementation below we are adding the IPython flag %%timeit at the top. This will run the whole block some number of times and report the best time back.\\nAdding some blank space below just to visually separate the answer.\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"CPU\\n\\nNote: the warning below doesn't mean you are using GPU. In fact it's using CPU here since I'm tracking the Windows Task Manager's \\\"Performance\\\".\\nTo track whether there is really GPU in use, need to make sure tf.config.experimental.list_physical_devices('GPU') has at least 1 GPU available.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Stacked LSTMs\\ndevice_name = '\\/cpu:0'\\nwith tf.device(device_name):\\n model_name = 'stacking_lstm_model_tanh_cpu'\\n model = stack_models(X_train, device_name)\\n history = fit_diy_model(model, X_train, y_train, X_val, y_val, model_name)\\n evaluate_diy_model(model_name, history, X_val, df_val)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Data_Analytics_in_Action\\/numpy.ipynb\\\".\\nThe first task is:\\n不形成的数组，直接修改数组的shape属性\\nCan you write Python code for it?\\n\",\"targets\":\"\\na.shape=(4,3)\\na\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Calculate Stats for Multiple Fields\\nUp to this point, we have focused on stats of a single field. Now we get into the meat of things, calculating stats across multiple fields and grouping by crop type (specified by the subclass property).\\nDetermine List of Sample Features\\nThere are just too many categorized crop fields to calculate statistics on them all in a reasonable time using just one CPU. Therefore, we will create a list of sample features, features that equally represent the crop types.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# determine the subclasses in this set and counts\\nsubclasses_list = [field_geojson['properties']['SUBCLASS1']\\n for field_geojson in cat_crop_ground_truth]\\nsubclasses = dict([x, subclasses_list.count(x)]\\n for x in set(subclasses_list))\\nprint('subclasses and counts')\\nprint(json.dumps(subclasses, indent=4))\\n\\n# number of samples for each subclass\\nnum_samples = 5\\n\\n# filter the subclasses to those with adequate number of features\\nfilt_subclasses = [subclass\\n for (subclass, count) in subclasses.items()\\n if count > num_samples]\\nprint('filtered subclasses: {}'.format(filt_subclasses))\\n\\n# lets focus on only 3 subclasses for now, comment to use all subclasses\\nfilt_subclasses = filt_subclasses[:3]\\nprint('filtered subclasses: {}'.format(filt_subclasses))\\n\\n# create a list of sample features\\n# first filter to features within a subclass, then randomly pick a sample of those features\\n\\nnp.random.seed(0) # make random sampling repeatable\\n\\nsample_features = []\\nfor subclass in filt_subclasses:\\n subclass_features = [f for f in crop_ground_truth if get_subclass(f) == subclass]\\n sample_features.extend(np.random.choice(subclass_features, num_samples, replace=False))\\nprint('{} sample field features'.format(len(sample_features)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"4. Results analysis\\nNow we can check the performance of the trained network by predicting the results of the test set and comparing them with the actual labels.\\nNote that the predict() function has been adapted to cope with the multi-class labels.\\n\",\"targets\":\"def predict(X, yOHE, parameters):\\n \\\"\\\"\\\"\\n This function is used to predict the results of a L-layer neural network.\\n It also checks them against the true labels and print the accuracy\\n Arguments:\\n X -- data set of examples you would like to label\\n yOHE -- the true labels, as multi-class vectors\\n parameters -- parameters of the trained model\\n \\n Returns:\\n p -- predictions (the label) for the given dataset X \\n \\\"\\\"\\\"\\n \\n m = X.shape[1]\\n nLabels = yOHE.shape[1]\\n n = len(parameters) \\/\\/ 2 # number of layers in the neural network\\n p = np.zeros((1, m)) # the predicted output, initialised to zero\\n y = np.zeros((1, m)) # the actual output\\n \\n # Forward propagation\\n probas, caches = L_model_forward(X, parameters)\\n\\n # probas is a matrix of shape [nLabels, m] (one-hot-encoded)\\n assert (probas.shape[1] == m)\\n \\n for i in range(0, m):\\n # convert probs to label predictions:\\n # just take the label with max prob\\n p[0,i] = np.argmax(probas[:,i])\\n\\n # convert expected results into label: takes the value with one\\n y[0,i] = np.argmax(yOHE[:,i])\\n \\n # print results\\n print(\\\"Accuracy: \\\" + str(np.sum((p == y)\\/m)))\\n \\n return p\\n\\nprint (\\\"On the training set:\\\")\\npredictions_train = predict(train_set_x, train_set_y, fit_params)\\nprint (\\\"On the test set:\\\")\\npredictions_test = predict(X_test.T, y_test.T, fit_params)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Below code will not work as f1 is not returning anything :). This is to show what can happen with one silly tab. Also it is one of the most common mistake.\\n\",\"targets\":\"def f1(a):\\n def f2(b):\\n return f2\\n def f3(c):\\n return f3\\n def f4(d):\\n return f4\\n def f5(e):\\n return f5\\ntry:\\n print (f1(1)(2)(3)(4)(5)) \\nexcept Exception as e:\\n print(e)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Compute the RSS of each of the three normalized weights on the (unnormalized) test_feature_matrix:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef cal_rss(feature_matrix, weights, output):\\n return rss(predict_output(feature_matrix, weights), output)\\n\\ncal_rss(test_feature_matrix, normalized_weights1e7, test_output)\\n\\ncal_rss(test_feature_matrix, normalized_weights1e8, test_output)\\n\\ncal_rss(test_feature_matrix, normalized_weights1e4, test_output)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Adding Average market price across all exchanges.\\n\",\"targets\":\"mkt_price = pd.read_csv(\\\"\\/Users\\/ibrahimgabr\\/Downloads\\/project-5\\/Data\\/blockchain.info\\/market_price_btc.csv\\\", header=None)\\nsubset_mkt_price = clean_blockchain_csv(mkt_price, ['date', \\\"mkt_price\\\"])\\ndf7 = pd.merge(df6, subset_mkt_price, on=\\\"date\\\", how=\\\"outer\\\")\\ndf7.head()\\n\\ndates_lst = df7['date']\\ndf7.head()\\n\\ndf7.drop([\\\"date\\\"],axis=1, inplace=True)\\nfeatures = \\\"+\\\".join(df7.columns[:-1])\\ny, X = dmatrices('mkt_price ~ ' + features, df7, return_type='dataframe')\\nvif = pd.DataFrame()\\nvif[\\\"VIF Factor\\\"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]\\nvif[\\\"features\\\"] = X.columns\\nvif.round(1) #looks like we are doing great!\\n\\ndf7.corr()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#Get variant list form vcf file\\nopen_file = myvariant_parsing_utils.VariantParsing()\\nlist_file = open_file.get_variants_from_vcf(vcf_file)\\n\\n#Run process\\nmy_variants = annotate_batch.AnnotationMethods()\\nmyvariant_data = my_variants.my_variant_at_once(list_file)\\n\\n#Name Collection & DB\\ncollection_name = 'My_Variant_Info_Collection_Full'\\ndb_name = 'My_Variant_Database'\\n\\n#Export\\nexporting_function = mongo_DB_export.export\\nexporting_function(myvariant_data, collection_name, db_name)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nMETHOD 3: ignore annovar, get data solely from myvariant\\nEasier to run, doesn't require annovar\\nWill however be incomplete (some variants will have no information).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"By default, PolynomialFeatures adds a constant term equal to 1. It corresponds to the intercept (or degree 0) of the model we are training.\\nLet's now define another linear regression and train it on the augmented features $\\\\phi(x) = \\\\left[1, x, x^2\\\\right]$.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nlinear_regression = LinearRegression()\\npolynomial_features = PolynomialFeatures(degree=2)\\npolynomial_X = polynomial_features.fit_transform(X[:, np.newaxis])\\nmy_regression = linear_regression.fit(polynomial_X, y)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%matplotlib inline\\n\\nimport matplotlib\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport tensorflow as tf\\n\\nfrom IPython.display import YouTubeVideo\\n\\nplt.style.use('bmh')\\nmatplotlib.rcParams['figure.figsize'] = (15, 4)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nChange Log\\nDate Created: 2017-03-24\\n\\nDate of Change Change Notes\\n-------------- ----------------------------------------------------------------\\n2017-03-24 Initial draft\\n\\nSetup\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# depth mean salinity\\ngrid.average(ds.SALT, ['Z']).plot();\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nGrid-aware (weighted) average\\nxgcm can also calcualate the weighted average along each axis and combinations of axes. \\nSee for example the vertical average of salinity:\\n$$ \\\\frac{\\\\int_{-H}^0 S dz}{\\\\int_{-H}^0 dz} $$\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Abtastung, Rekonstruktion der gesendeten Symbole\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nr = rt[2*group_delay:-2*group_delay:M]\\n\\nplt.stem(r[:20]); \\nplt.title(\\\"RX symbols after sampling\\\"); plt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Notebooks\\/.ipynb_checkpoints\\/AppendMicrosoftAIData-checkpoint.ipynb\\\".\\nThe first task is:\\nGenerate rank list of tags by share rate.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntgsShrNoShrCount = {}\\nfor lst in rnkFlLst:\\n tgs = gidFtrs[lst[0]]\\n tmpDict = {'share': int(lst[1]), 'not_share': int(lst[2]), 'total' : int(lst[3])}\\n for tag in tgs:\\n oldDict ={}\\n oldDict = tgsShrNoShrCount.get(tag,{'share' : 0,'not_share' : 0,'total' : 0})\\n oldDict['share'] = oldDict.get('share',0) + tmpDict['share']\\n oldDict['not_share'] = oldDict.get('not_share',0) + tmpDict['not_share']\\n oldDict['total'] = oldDict.get('total',0) + tmpDict['total']\\n\\n tgsShrNoShrCount[tag] = oldDict\\n\\n## Append data into data frames and build visualizations\\ntgsShrCntDf = pd.DataFrame(tgsShrNoShrCount).transpose()\\ntgsShrCntDf['proportion'] = tgsShrCntDf['share'] * 100 \\/ tgsShrCntDf['total']\\ntgsShrCntDf.sort_values(by=['proportion','share'],ascending=False,inplace=True)\\ntgsShrCntDf = tgsShrCntDf[['share','not_share','total','proportion']]\\ntgsShrCntDf.to_csv(\\\"..\\/FinalResults\\/RankListTags.csv\\\")\\n\\nfullFl = HT.html(HT.body(HT.HTML(tgsShrCntDf.to_html(bold_rows = False))))\\n\\noutputFile = open(\\\"..\\/FinalResults\\/RankListTags.html\\\",\\\"w\\\")\\noutputFile.write(fullFl)\\noutputFile.close()\\n\\niFrameBlock = []\\nfig = tgsShrCntDf['proportion'].iplot(kind='line',filename=\\\"All_Tags\\\",title=\\\"Distribution of Tags\\\")\\niFrameBlock.append(fig.embed_code)\\n#plt.savefig(\\\"..\\/FinalResults\\/RankListTags.png\\\",bbox_inches='tight')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#set the number of threads to use for your machine \\nnum_threads=20\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nConclusions\\n\\nNo spacers hit any protospacers on the Ecoli genomes in the CLdb!\\nThis indicates that there are no interegrated mobile genetic elements in the E.coli genomes that can be detected using the CRISPR spacers.\\nMaybe we will get some hits when we blast against NCBI's nt database.\\n\\nArray Blast vs NCBI's nt database\\n\\nNOTE: you will need the BLAST nt database & the blast+ toolkit\\nThe arrayBlast wrapper only works with the genomes in CLdb.\\nWe will need to do this part 'manually'\\nThe blast output just needs to be in .xml format.\\nYou will need the BLAST nt database\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"FastRoot.ipynb\\\".\\nThe first task is:\\nHmm, weren't we expecting 0x5f3759df instead of 0x5f400000?\\n * It turns out that magic constants that are close to each other have nearly identicle behavior. Here, 0x5f3759df is only 0.035% away from 0x5f400000! Close enough.\\nBehold! The Fast Arbitrary Power Method!\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef qexp(C):\\n # (1 - C) * f2l(1) + C * f2l(x)\\n return np.vectorize(lambda x: l2f((1 - C) * f2l(1) + C * f2l(x)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Add landsat and cloud mask to a common Xarray\\n\",\"targets\":\"product_dataset = xr.merge([year_of_landsat_dataset, is_clear_mask])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Converting categorical feature to numeric\\nWe can now convert the EmbarkedFill feature by creating a new numeric Port feature.\\n\",\"targets\":\"for dataset in combine:\\n dataset['Embarked'] = dataset['Embarked'].map( {'S': 0, 'C': 1, 'Q': 2} ).astype(int)\\n\\ntrain_df.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Compute MNE-dSPM inverse solution on single epochs\\nCompute dSPM inverse solution on single trial epochs restricted\\nto a brain label.\\n\",\"targets\":\"# Author: Alexandre Gramfort \\n#\\n# License: BSD (3-clause)\\n\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\n\\nimport mne\\nfrom mne.datasets import sample\\nfrom mne.minimum_norm import apply_inverse_epochs, read_inverse_operator\\nfrom mne.minimum_norm import apply_inverse\\n\\nprint(__doc__)\\n\\ndata_path = sample.data_path()\\nfname_inv = data_path + '\\/MEG\\/sample\\/sample_audvis-meg-oct-6-meg-inv.fif'\\nfname_raw = data_path + '\\/MEG\\/sample\\/sample_audvis_filt-0-40_raw.fif'\\nfname_event = data_path + '\\/MEG\\/sample\\/sample_audvis_filt-0-40_raw-eve.fif'\\nlabel_name = 'Aud-lh'\\nfname_label = data_path + '\\/MEG\\/sample\\/labels\\/%s.label' % label_name\\n\\nevent_id, tmin, tmax = 1, -0.2, 0.5\\n\\n# Using the same inverse operator when inspecting single trials Vs. evoked\\nsnr = 3.0 # Standard assumption for average data but using it for single trial\\nlambda2 = 1.0 \\/ snr ** 2\\n\\nmethod = \\\"dSPM\\\" # use dSPM method (could also be MNE or sLORETA)\\n\\n# Load data\\ninverse_operator = read_inverse_operator(fname_inv)\\nlabel = mne.read_label(fname_label)\\nraw = mne.io.read_raw_fif(fname_raw)\\nevents = mne.read_events(fname_event)\\n\\n# Set up pick list\\ninclude = []\\n\\n# Add a bad channel\\nraw.info['bads'] += ['EEG 053'] # bads + 1 more\\n\\n# pick MEG channels\\npicks = mne.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=True,\\n include=include, exclude='bads')\\n# Read epochs\\nepochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks,\\n baseline=(None, 0), reject=dict(mag=4e-12, grad=4000e-13,\\n eog=150e-6))\\n\\n# Get evoked data (averaging across trials in sensor space)\\nevoked = epochs.average()\\n\\n# Compute inverse solution and stcs for each epoch\\n# Use the same inverse operator as with evoked data (i.e., set nave)\\n# If you use a different nave, dSPM just scales by a factor sqrt(nave)\\nstcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, method, label,\\n pick_ori=\\\"normal\\\", nave=evoked.nave)\\n\\n# Mean...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Define a class to hold a satellite or aerial imagery file. Its properties give information\\n# such as location of the ground, area, dimensions, spatial and spectral resolution etc.\\n\\nclass ImageryObject:\\n _default_gsd = 5.0\\n \\n def __init__(self, file_path):\\n self._file_path = file_path\\n self._gps_location = (3,4)\\n \\n @property\\n def bands(self):\\n #count number of bands\\n count = 3\\n return count\\n \\n @property\\n def gsd(self):\\n # logic to calculate the ground sample distance\\n gsd = 10.0\\n return gsd\\n \\n @property\\n def address(self):\\n # logic to reverse geocode the self._gps_location to get address\\n # reverse geocode self._gps_location\\n address = \\\"123 XYZ Street\\\"\\n return address\\n \\n #class methods\\n def display(self):\\n #logic to display picture\\n print(\\\"image is displayed\\\")\\n \\n def shuffle_bands(self):\\n #logic to shift RGB combination\\n print(\\\"shifting pands\\\")\\n self.display()\\n\\n# class instantiation\\nimg1 = ImageryObject(\\\"user\\\\img\\\\file.img\\\") #pass value to constructor\\n\\nimg1.address\\n\\nimg1._default_gsd\\n\\nimg1._gps_location\\n\\nimg1.shuffle_bands()\\n\\n# Get help on any object. Only public methods, properties are displayed.\\n# fields are private, properties are public. Class variables beginning with _ are private fields.\\nhelp(img1)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nClasses\\nEverything is an object in Python including native types. You define class names with camel casing.\\nYou define the constructor with special name __init__(). The fields (private) are denoted with _variable_name specification and properties are decorated with @property decorator.\\nFields and properties are accessed within the class using self.name notation. This helps differentiate a class field \\/ property from a local variable or method argument of the same name.\\nA simple class\\nclass MyClass:\\n _local_variables = \\\"value\\\"\\n\\n def __init__(self, args): #constructor\\n statements\\n self._local_variables = args # assign values to fields\\n\\n def func_1(self, args):\\n statements\\n\\nYou use this method by instantiating an object.\\nobj1 = myClass(args_defined_in_constructor)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%writefile training_image\\/trainer\\/glue_mnli_matched.yaml\\n\\ntask:\\n hub_module_url: 'https:\\/\\/tfhub.dev\\/tensorflow\\/bert_en_uncased_L-24_H-1024_A-16\\/4'\\n model:\\n num_classes: 3\\n init_checkpoint: ''\\n metric_type: 'accuracy'\\n train_data:\\n drop_remainder: true\\n global_batch_size: 32\\n input_path: ''\\n is_training: true\\n seq_length: 128\\n label_type: 'int'\\n validation_data:\\n drop_remainder: false\\n global_batch_size: 32\\n input_path: ''\\n is_training: false\\n seq_length: 128\\n label_type: 'int'\\ntrainer:\\n checkpoint_interval: 3000\\n optimizer_config:\\n learning_rate:\\n polynomial:\\n # 100% of train_steps.\\n decay_steps: 36813\\n end_learning_rate: 0.0\\n initial_learning_rate: 3.0e-05\\n power: 1.0\\n type: polynomial\\n optimizer:\\n type: adamw\\n warmup:\\n polynomial:\\n power: 1\\n # ~10% of train_steps.\\n warmup_steps: 3681\\n type: polynomial\\n steps_per_loop: 1000\\n summary_interval: 1000\\n # Training data size 392,702 examples, 3 epochs.\\n train_steps: 36813\\n validation_interval: 6135\\n # Eval data size = 9815 examples.\\n validation_steps: 307\\n best_checkpoint_export_subdir: 'best_ckpt'\\n best_checkpoint_eval_metric: 'cls_accuracy'\\n best_checkpoint_metric_comp: 'higher'\\nruntime:\\n distribution_strategy: 'multi_worker_mirrored'\\n all_reduce_alg: 'nccl'\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreate base settings for the MNLI fine tuning experiment\\nThe TensorFlow NLP Modelling Toolkit includes a predefined experiment for a set of text classification tasks, the bert\\/sentence_prediction experiment. The base settings in the bert\\/sentence_prediction experiment need to be updated for the MNLI fine tuning task you perform in this example.\\nIn the next cell, you update the settings by creating a YAML configuration file that will be referenced when invoking a training script. As noted earlier, you can fine tune these settings even further for each training run by using the --params_override flag.\\nThe configuration file has three sections: task, trainer, and runtime.\\n* The task section contains settings specific to your machine learning task, including a URI to a pre-trained BERT model, training and validation datasets settings, and evaluation metrics. \\n* The trainer section configures the settings that control the custom training loop, like checkpoint interval or a number of training steps. \\n* The runtime section includes the settings for a training runtime: a distributed training strategy, GPU configurations, etc.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create a MODFLOW model and store it (in this case in the variable ml, but you can call it whatever you want). The modelname will be the name given to all MODFLOW files (input and output). The exe_name should be the full path to your MODFLOW executable. The version is either 'mf2k' for MODFLOW2000 or 'mf2005'for MODFLOW2005.\\n\",\"targets\":\"ml = mf.Modflow(modelname=name, exe_name='mf2005', version='mf2005', model_ws=workspace)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"(2) vs. macrocycle_depth\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nvs_depth_df, vs_depth_gb_cols = analysis.groupby_all_except(\\n means_df, \\n y_cols=('macrocycle_depth', 'success_probability_mean', 'success_probability_std'),\\n agg_func=list\\n)\\nvs_depth_df\\n\\nfor i, row in vs_depth_df.iterrows():\\n plt.errorbar(\\n x=row['macrocycle_depth'],\\n y=row['success_probability_mean'],\\n yerr=row['success_probability_std'],\\n label=', '.join(f'{row[col]}' for col in vs_depth_gb_cols),\\n capsize=5, ls='', marker='o',\\n )\\n \\nplt.xlabel('Macrocycle Depth')\\nplt.ylabel('Success Probability')\\nplt.legend(title=','.join(vs_depth_gb_cols), loc='best')\\nplt.tight_layout()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"6. Train Machine Learning Object\\n\\nExecute the stages in the pipeline including featurization and model training on test data using fit<\\/b>\\n\\nusing https:\\/\\/spark.apache.org\\/docs\\/2.1.1\\/api\\/python\\/pyspark.ml.html#pyspark.ml.Pipeline.fit\\n\",\"targets\":\"model = pipeline.fit(trainingData)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Case study: S&P500 company clusters\\nStep 1: Using the sp500_tfidf_dense array\\/DataFrame, experiment with different dimensionality reduction tools we covered above. Visualize and inspect the distribution of S&P500 companies for interesting dimensions (do X and Y dimensions in this reduced data capture anything meaningful?) or clusters (do companies clusters together as we'd expect?).\\nVisualizing word embeddings\\nUsing the bio_counts, we can find the top-N most frequent words and save them as top_words.\\n\",\"targets\":\"top_words = pd.DataFrame(bio_counts.todense().sum(0).T,\\n index=count_vect.get_feature_names())[0]\\n\\ntop_words = top_words.sort_values(0,ascending=False).head(1000).index.tolist()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# company and stocks\\nprices = {'ACME': 45.23, 'AAPL': 612.78, 'IBM': 205.55,\\n 'HPQ': 37.20, 'FB': 10.75}\\n\\nmin_price = min(zip(prices.values(), prices.keys()))\\nprint(min_price)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCalculating with Dictionaries Using zip\\nPerforming calculations (e.g., min, max, sorting, etc.) on a dictionary by convert the it into tuples of ( value, key ).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"ME249-Lecture-3.ipynb\\\".\\nThe first task is:\\n\\nSolve the questions in green blocks. Save the file as ME249-Lecture-3-YOURNAME.ipynb and change YOURNAME in the bottom cell. Send me and the grader the html<\\/b> file not the ipynb file. \\n<\\/p>\\n\\nDiscrete Fourier Series<\\/h1>\\n\\nConsider a function $f$ periodic over a domain $0\\\\leq x\\\\leq 2\\\\pi$, discretized by $N_x$ points. The longest wavelength wave that can be contained in the domain is $L_x$. A phyiscal understanding of Fourier series is the representation of a system as the sum of many waves fo wavelengths smaller or equal to $L_x$. In a discrete sense, the series of wave used to decompose the system is defined as:\\n$$\\na_n\\\\exp\\\\left(\\\\hat{\\\\jmath}\\\\frac{2\\\\pi n}{Lx}\\\\right)\\n$$\\nsuch that\\n\\n$$\\nf(x) = \\\\sum_{n=-\\\\infty}^{\\\\infty}a_n\\\\exp\\\\left(\\\\hat{\\\\jmath}\\\\frac{2\\\\pi nx}{Lx}\\\\right)\\n$$\\n<\\/p>\\nand \\n \\n$$\\na_n = \\\\frac{1}{L_x}\\\\int_Lf(x)\\\\exp\\\\left(-\\\\hat{\\\\jmath}\\\\frac{2\\\\pi nx}{Lx}\\\\right)dx\\n$$\\n<\\/p>\\nHere $\\\\hat{\\\\jmath}^2=-1$.Often the reduction to wavenumber is used, where\\n \\n$$\\nk_n = \\\\frac{2\\\\pi n}{L_x}\\n$$\\n<\\/p>\\nNote that if $x$ is time instead of distance, $L_x$ is a time $T$ and the smallest frequency contained in the domain is $f_0=1\\/T_0$ and the wavenumber $n$ is $k_n=2\\\\pi f_0n=2\\\\pi f_n$ with $f_n$ for $\\\\vert n\\\\vert >1$ are the higher frequencies. \\nDiscrete Fourier Transform (DFT)<\\/h1>\\n\\nIn scientific computing we are interested in applying Fourier series on vectors or matrices, containing a integer number of samples. The DFT is the fourier series for the number of samples. DFT functions available in python or any other language only care about the number of samples, therefore the wavenumber is \\n\\n$$\\nk_n=\\\\frac{2\\\\pi n}{N_x}\\n$$\\n<\\/p>\\nConsider a function $f$ periodic over a domain $0\\\\leq x\\\\leq 2\\\\pi$, discretized by $N_x$ points. The nodal value is $f_i$ located at $x_i=(i+1)\\\\Delta x$ with $\\\\Delta x=L_x\\/Nx$. The DFT is defined as\\n \\n# Daniel Strohmeier \\n#\\n# License: BSD-3-Clause\\n\\nimport numpy as np\\n\\nimport mne\\nfrom mne.datasets import sample\\nfrom mne.minimum_norm import make_inverse_operator, apply_inverse\\nfrom mne.inverse_sparse import tf_mixed_norm, make_stc_from_dipoles\\nfrom mne.viz import (plot_sparse_source_estimates,\\n plot_dipole_locations, plot_dipole_amplitudes)\\n\\nprint(__doc__)\\n\\ndata_path = sample.data_path()\\nsubjects_dir = data_path + '\\/subjects'\\nfwd_fname = data_path + '\\/MEG\\/sample\\/sample_audvis-meg-eeg-oct-6-fwd.fif'\\nave_fname = data_path + '\\/MEG\\/sample\\/sample_audvis-no-filter-ave.fif'\\ncov_fname = data_path + '\\/MEG\\/sample\\/sample_audvis-shrunk-cov.fif'\\n\\n# Read noise covariance matrix\\ncov = mne.read_cov(cov_fname)\\n\\n# Handling average file\\ncondition = 'Left visual'\\nevoked = mne.read_evokeds(ave_fname, condition=condition, baseline=(None, 0))\\nevoked = mne.pick_channels_evoked(evoked)\\n# We make the window slightly larger than what you'll eventually be interested\\n# in ([-0.05, 0.3]) to avoid edge effects.\\nevoked.crop(tmin=-0.1, tmax=0.4)\\n\\n# Handling forward solution\\nforward = mne.read_forward_solution(fwd_fname)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Alternatively, you can specify timestamps between two time intervals, such as 10:00 AM and 10:01 AM (inclusively).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nts.between_time(time(10, 0), time(10, 1))\\n\\nnp.random.seed(12346)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Final_Version_With_Decision_Tree.ipynb\\\".\\nThe first task is:\\nLoad in the Data\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf = pd.read_csv('C:\\/Users\\/Collin\\/Documents\\/Python_Projects\\/TxDOT\\/data\\/Bid_Data.csv')\\nlen(df)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"After writing the six sequences to the handle, MUSCLE will still be\\nwaiting to see if that is all the FASTA sequences or not – so we must\\nsignal that this is all the input data by closing the handle. At that\\npoint MUSCLE should start to run, and we can ask for the output:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom Bio import AlignIO\\nalign = AlignIO.read(child.stdout, \\\"clustal\\\")\\nprint(align)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2.3. Fit the model\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprepared_training_data = prepare_data(train_data)\\n\\nimport time\\nfrom sklearn.covariance import EllipticEnvelope\\n\\nmodel = EllipticEnvelope(contamination=0.)\\n\\nprint(\\\"Fitting...\\\")\\nt0 = time.time()\\nmodel.fit(prepared_training_data)\\nt1 = time.time()\\nprint(\\\"Model is fitted in {} seconds.\\\".format(round(t1-t0)))\\n\\n\\nimport statistics\\n\\ntraining_distances = model.mahalanobis(prepared_training_data)\\nmodel._mean = statistics.mean(training_distances)\\nmodel._stdv = statistics.stdev(training_distances)\\nprint(\\\"training distance mean: {}\\\".format(round(model._mean, 5))) \\nprint(\\\"training distance stdv: {}\\\".format(round(model._stdv, 5)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And then predict with our model:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nwith torch.no_grad():\\n new_net.cuda()\\n tfmd_im = tfmd_im.cuda()\\n preds = new_net(tfmd_im)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Calculate correlations between the each realization of $\\\\delta^{18}O$ and SST in each grid cell\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n#correlation\\n#sst_ann_new=sst_ann_fil.transpose(1,2,0)\\nsst_ann_new=sst_ann_fil.transpose(\\\"lat\\\",\\\"lon\\\",\\\"time\\\")\\nd18O_new=np.transpose(d18O_fil)\\n\\nsst_ano=np.ma.anomalies(sst_ann_new,axis=2)\\nd18O_ano=np.ma.anomalies(d18O_new,axis=0)\\nnomi=np.dot(sst_ano,d18O_ano)\\n\\nsst_sd=np.sum(sst_ano**2,axis=2)\\nd18O_sd=np.sum(d18O_ano**2,axis=0)\\n\\nd18O_median_ano=np.ma.anomalies(d18O_median)\\nd18O_median_sd=np.sum(d18O_median_ano**2,axis=0)\\nnomi_median=np.dot(sst_ano,d18O_median_ano)\\n\\ncorr_sst=nomi\\/np.sqrt(np.dot(sst_sd[:,:,None],d18O_sd[None,:]))\\ncorr_sst_median=nomi_median\\/np.sqrt(np.dot(sst_sd[:,:,None],d18O_median_sd[None]))\\ncorr_sst_new=np.reshape(corr_sst,(nlat*nlon,1000))\\ncorrQ = mquantiles(corr_sst_new, prob=[0.025, 0.5, 0.975], axis=1)\\ncorrQ_new = np.reshape(corrQ,(nlat,nlon,3))\\n#Interquatile Range\\nIQR=corrQ_new[:,:,2]-corrQ_new[:,:,0]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"1-pandas.ipynb\\\".\\nThe first task is:\\nEXERCISE: Plot the number of reviews timeseries by month, year\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Your code here\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Again, just as we did in the plant loop, we can change the components of the loop, by replacing the branchs and traverse the loop using the functions nextnode() and prevnode()\\nBuilding an Air Loop\\nBuilding an air loop is similar to the plant and condensor loop. The difference is that instead of pipes , we have ducts as placeholder components. The other difference is that we have zones on the demand side.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nairloop_idf = IDF(StringIO('')) \\nloopname = \\\"a_loop\\\"\\nsloop = ['sb0', ['sb1', 'sb2', 'sb3'], 'sb4'] # supply side of the loop\\ndloop = ['zone1', 'zone2', 'zone3'] # zones on the demand side\\nhvacbuilder.makeairloop(airloop_idf, loopname, sloop, dloop)\\nairloop_idf.saveas(\\\"a_loop.idf\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Convolution and Max Pooling Layer\\nConvolution layers have a lot of success with images. For this code cell, you should implement the function conv2d_maxpool to apply convolution then max pooling:\\n* Create the weight and bias using conv_ksize, conv_num_outputs and the shape of x_tensor.\\n* Apply a convolution to x_tensor using weight and conv_strides.\\n * We recommend you use same padding, but you're welcome to use any padding.\\n* Add bias\\n* Add a nonlinear activation to the convolution.\\n* Apply Max Pooling using pool_ksize and pool_strides.\\n * We recommend you use same padding, but you're welcome to use any padding.\\nNote: You can't use TensorFlow Layers or TensorFlow Layers (contrib) for this layer, but you can still use TensorFlow's Neural Network package. You may still use the shortcut option for all the other layers.\\n\",\"targets\":\"def conv2d_maxpool(x_tensor, conv_num_outputs, conv_ksize, conv_strides, pool_ksize, pool_strides):\\n \\\"\\\"\\\"\\n Apply convolution then max pooling to x_tensor\\n :param x_tensor: TensorFlow Tensor\\n :param conv_num_outputs: Number of outputs for the convolutional layer\\n :param conv_ksize: kernal size 2-D Tuple for the convolutional layer\\n :param conv_strides: Stride 2-D Tuple for convolution\\n :param pool_ksize: kernal size 2-D Tuple for pool\\n :param pool_strides: Stride 2-D Tuple for pool\\n : return: A tensor that represents convolution and max pooling of x_tensor\\n \\\"\\\"\\\"\\n # TODO: Implement Function\\n '''\\n # These are the two seprate examples from Lesson 4.31 and 4.33 from Convolutional Networks\\n\\n def conv2d(input):\\n \\n # Filter (weights and bias)\\n F_W = tf.Variable(tf.truncated_normal((2, 2, 1, 3)))\\n F_b = tf.Variable(tf.zeros(3))\\n \\n strides = [1, 2, 2, 1]\\n \\n padding = 'VALID'\\n \\n return tf.nn.conv2d(input, F_W, strides, padding) + F_b\\n \\n def maxpool(input):\\n # Set the ksize (filter size) for each dimension (batch_size, height, width, depth)\\n ksize = [1, 2, 2, 1]\\n \\n # Set the stride for each dimension (batch_size, height, width, depth)\\n strides = [1, 2, 2, 1]\\n \\n # set the padding, either 'VALID' or 'SAME'.\\n padding = 'VALID'\\n \\n # https:\\/\\/www.tensorflow.org\\/versions\\/r0.11\\/api_docs\\/python\\/nn.html#max_pool\\n return tf.nn.max_pool(input, ksize, strides, padding)\\n '''\\n #print(x_tensor, \\\"conv num output\\\", conv_num_outputs, \\\"conv_ksize\\\", conv_ksize, \\\"conv_strides\\\", conv_strides,\\n # \\\"pool_ksize\\\", pool_ksize, \\\"pool_strides\\\", pool_strides)\\n \\n # Filter (weights and bias)\\n conv_filter_weights = tf.Variable(tf.truncated_normal([conv_ksize[0],\\n conv_ksize[1],\\n x_tensor.get_shape().as_list()[-1],\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# map Embarked port character to full name of each town\\ntitanic['Embarked'] = titanic['Embarked'].dropna().map({'C' : 'Cherbourg', 'Q' : 'Queenstown', 'S': 'Southampton' })\\n\\n\\n# Check passenger who from\\n\\npassenger_by_embark_who = titanic.groupby('Embarked')\\nprint passenger_by_embark_who.count()['Passenger']\\n\\n# set plot title\\nax = sns.plt.title('Port of Embarkation')\\n\\n# show the counts of passengers\\nax = sns.countplot(x = 'Embarked', data = titanic)\\n\\n# add percentage for each group\\nfor p in ax.patches:\\n height = p.get_height()\\n ax.text(p.get_x(), height + 10, '%1.2f'%((height*100)\\/passengercount))\\n\\n# Check passenger who from\\n\\npassenger_by_embark_who = titanic.groupby(['Embarked','Who'])\\nprint passenger_by_embark_who.count()['Passenger']\\n\\n# set plot title\\nax = sns.plt.title('Port of Embarkation')\\n\\n# show the counts of passengers\\nax = sns.countplot(x = 'Embarked', hue = 'Who', data = titanic)\\n\\n# add percentage for each group\\nfor p in ax.patches:\\n height = p.get_height()\\n ax.text(p.get_x(), height + 10, '%1.2f'%((height*100)\\/passengercount))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPassenger class look not difference for each class\\n3.) Where are the passengers came from?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Calculating flux\\nYou might as well be interested in calculating the mass flux from a boundary! This is easily done in OpenPNM via calling the rate method attached to the algorithm. Let's see how it works:\\n\",\"targets\":\"rate_inlet = fd.rate(pores=inlet)[0]\\nprint(f'Mass flow rate from inlet: {rate_inlet:.5e} mol\\/s')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Pandas_Introduction.ipynb\\\".\\nThe first task is:\\nLet's add a column to the DataFrame\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf['E'] = ['one', 'one','two','three','four','three']\\n\\ndf\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Code\\/notebooks\\/bootcamp_pandas-summarize.ipynb\\\".\\nThe first task is:\\nComment. If we add enough quantiles, we might as well plot the whole distribution. The easiest way to do this is with a histogram.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfig, ax = plt.subplots()\\ndb01.hist(bins=15, ax=ax, alpha=0.35)\\nax.set_xlabel('Government Debt (Percent of GDP)')\\nax.set_ylabel('Number of Countries')\\n\\nymin, ymax = ax.get_ylim()\\nax.vlines(db01['ARG'], ymin, ymax, color='blue', lw=2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"MNIST\\/Atelier-keras-MNIST.ipynb\\\".\\nThe first task is:\\nAutre architecture\\nRéseau\\nTest d'un réseau de convolution constitué de 7 couches: \\n\\nUne couche de convolution 2D, avec fenêtre de taille 3x3 et une fonction d'activation relu\\nUne couche de convolution 2D, avec fenêtre de taille 3x3 et une fonction d'activation relu\\nUne couche max pooling de fenêtre 2x2\\nUne couche dropout où 25% des neurones sont desactivés\\nUne couche Flatten transforme les images $N \\\\times N$ en vecteurs $N^2$.\\nUne couche classique de 128 neurones\\nUne couche dropout ou 50% des neurones sont desactivés\\n\\nUne couche softmax fournit la classification\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# descrition du réseau\\nmodel = km.Sequential()\\nmodel.add(kl.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28,28, 1), data_format=\\\"channels_last\\\"))\\nmodel.add(kl.Conv2D(64, (3, 3), activation='relu'))\\nmodel.add(kl.MaxPooling2D(pool_size=(2, 2)))\\nmodel.add(kl.Dropout(0.25))\\nmodel.add(kl.Flatten())\\nmodel.add(kl.Dense(128, activation='relu'))\\nmodel.add(kl.Dropout(0.5))\\nmodel.add(kl.Dense(N_classes, activation='softmax'))\\n# Résumé\\nmodel.summary()\\n# Apprentissage\\nmodel.compile(loss=\\\"categorical_crossentropy\\\",\\n optimizer=ko.Adadelta(),\\n metrics=['accuracy'])\\nts=time.time()\\nmodel.fit(X_train_conv, Y_train_cat,\\n batch_size=batch_size,\\n epochs=epochs,\\n verbose=1,\\n validation_data=(X_test_conv, Y_test_cat))\\nte=time.time()\\nt_train_conv = te-ts\\n\\nscore_conv = model.evaluate(X_test_conv, Y_test_cat, verbose=0)\\npredict_conv = model.predict(X_test_conv)\\nprint('Test loss:', score_conv[0])\\nprint('Test accuracy:', score_conv[1])\\nprint(\\\"Time Running: %.2f seconds\\\" %t_train_conv )\\n\\nfig=plt.figure(figsize=(7,6))\\nax = fig.add_subplot(1,1,1)\\nax = sb.heatmap(pd.DataFrame(confusion_matrix(Y_test, predict_conv.argmax(1))), annot=True, fmt=\\\"d\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Both test classes invoke the read(...) method, but only postTwiceCreatesTwoElements() calls getContent() – and this for five times. This explains the dissimilarity between both test methods.\\nIn contrast, we can have a look at the method void keyWorks() from the test class ConfigurationFileTest, which has absolutely nothing to do (= dissimilarity 1.0) with the method readRoundtripWorksWithFullData() nor the underlying calls to the production code.\\njava\\n @Test\\n public void keyWorks() {\\n assertEquals(\\\"InMemory\\\", config.get(\\\"gateway.type\\\"));\\n }\\nLooking at the corresponding invocation data, we see, that there are no common uses of production methods.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ninvocations[\\n (invocations.test_method == \\\"void readRoundtripWorksWithFullData()\\\") |\\n (invocations.test_method == \\\"void keyWorks()\\\")]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Ahora sí, podemos correr el mismo modelo de antes pero sobre nuestros datos agregados (recordemos que antes hay que normalizarlos):\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nvariables = agregados[['entrada','viv','entropia']]\\nvars_norm = (variables - variables.mean())\\/variables.std()\\nmodel = sm.ols(formula=\\\"entrada ~ viv + entropia\\\",data=vars_norm).fit()\\nprint model.summary()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And finally for periods 49-52 (the caption in the table for McKPal95 says 48-52). Our lambda of $\\\\approx 10^7$ translates\\nessentially to infinity, i.e., Nash equilibrium.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndata4 = g.mixed_strategy_profile()\\ndata4[g.players[0]] = [ 4*128*0.455, 4*128*(1.0-0.455) ]\\ndata4[g.players[1]] = [ 4*128*0.285, 4*128*(1.0-0.285) ]\\nqre4 = gambit.nash.logit_estimate(data4)\\nqre4\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A reaction can also connect to multiple events:\\n\",\"targets\":\"class MyObject(event.Component):\\n \\n @event.reaction('!foo', '!bar')\\n def on_foo_or_bar(self, *events):\\n for ev in events:\\n print('received the %s event' % ev.type)\\n\\nob = MyObject()\\nob.emit('foo', {}); ob.emit('foo', {}); ob.emit('bar', {})\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%matplotlib inline\\nimport numpy as np\\nimport time\\nnetwork_size=20\\nstart_time = time.time()\\n#alpha_list = [0.01,0.05,0.08,0.10,0.12,0.15,0.20,0.30]\\nalpha_list = np.arange(0.07,0.22,0.010\\n )\\nm_list = []\\nhopfield_net = network.HopfieldNetwork(nr_neurons= network_size**2)\\nfactory = pattern_tools.PatternFactory(network_size,network_size)\\n# create a checkerboard pattern and add it to the pattern list\\n#checkerboard = factory.create_checkerboard()\\n#pattern_list = [checkerboard]\\npattern_list=[]\\npattern_list.extend(factory.create_random_pattern_list(nr_patterns=int(alpha_list[-1]*network_size*network_size), on_probability=0.5))\\n\\nfor alpha in alpha_list:\\n \\n\\n# create an instance of the class HopfieldNetwork\\n \\n\\n\\n# let the hopfield network \\\"learn\\\" the patterns. Note: they are not stored\\n# explicitly but only network weights are updated !\\n hopfield_net.store_patterns(pattern_list[0:int(alpha*network_size*network_size)])\\n\\n# create a noisy version of a pattern and use that to initialize the network\\n noisy_init_state=pattern_tools.flip_n(pattern_list[0],nr_of_flips=int(network_size*network_size*0.15)) # 10% of noisy pixels\\n\\n hopfield_net.set_state_from_pattern(noisy_init_state)\\n states_as_patterns_old = [noisy_init_state]\\n states_as_patterns_new = [pattern_list[0]]\\n# from this initial state, let the network dynamics evolve.\\n#hopfield_net.run(nr_steps=50)\\n #while pattern_tools.compute_overlap(states_as_patterns_old[0],states_as_patterns_new[0]) < 0.95:\\n #print pattern_tools.compute_overlap(states_as_patterns_old[0],states_as_patterns_new[0])\\n #states_as_patterns_old = states_as_patterns_new\\n #states_new = hopfield_net.run_with_monitoring(nr_steps=1)\\n #states_as_patterns_new = factory.reshape_patterns(states_new)\\n# each network state is a vector. reshape it to the same shape used to create the patterns.\\n hopfield_net.run(nr_steps=60)\\n states = hopfield_net.run_with_monitoring(nr_steps=1)\\n states_as_patterns = factory.reshape_patterns(states)\\n...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAs we can observe as we eprform the dynamics of the Hopfield model, the total energy of the network is strongly decreasing. This is in accordance with the physical interpretation we had. But even if we always have a decreasing energy (even with wrong recovery), we can observe a typical behavior of the magnetization $m$ (or correlation) as function of $p\\/N$.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%load_ext pyensae\\n\\n%SQL_connect td8_velib.db3\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n## Premières requêtes SQL\\nDans notre cas, on va faire cela depuis le notebook.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# we can also write the predicates directly using lambda notation \\nest_even = len([x for x in samples if x%2==0]) \\/ len(samples)\\nest_2 = len([x for x in samples if x==2]) \\/ len(samples)\\nest_4 = len([x for x in samples if x==4]) \\/ len(samples)\\nest_6 = len([x for x in samples if x==6]) \\/ len(samples)\\nprint(est_even)\\n# Let's print some estimates \\nprint('Estimates of 2,4,6 = ', (est_2, est_4, est_6))\\nprint('Direct estimate = ', est_even) \\nprint('Sum of estimates = ', est_2 + est_4 + est_6)\\nprint('Theoretical value = ', 0.5)\\n\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLet's now estimate the frequency of the event roll even number in different ways. \\nFirst let's count the number of even numbers in the generated samples. Then let's \\ntake the sum of the counts of the individual estimated probabilities.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Analyzing Resolution Effectiveness\\nA key question we are trying to explore in this project is how effectively these 311 requests get resolved. Below, we outline resolution details by year. Our key variable of interest in exploring resolution effectiveness is Status.\\nIn Status, we are specifically looking for 'Closed' status. This is assigned for a variety of reasons: no violations were found, complaint has been addressed, complaint is deferred, etc... Other status like 'Assigned' and 'Open' have violations that are being addressed or in progress. Overall, Closed gives a good idea of requests that at least get a response. Other statuses also seem to show progress towards resolve. \\n\\nIssues with Our Target Variable:\\nThere are some issues with our target variable that affects our analysis. The 'Closed' status can be inflated if requests are simply deferred instead of being addressed. When these agencies cannot address the resolution because of reasons like tenants not being home or building not being reachable, they close the complaint. This can also affect our analysis as requests are not really being addressed, but only acknowledged. Nevertheless, we believe the Status feature still gives a good analysis of the agencies' response, regardless of what the response is. With the data we are working with, this is the best we can do. \\n\\nBelow, we graph the percentage of complaints that were closed each year.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nclosedcomplaints= []\\ntotalcomplaints=[]\\ndataframes= [data2010,data2011,data2012,data2013,data2014,data2015,data2016]\\nfor i in dataframes:\\n closedcomplaints.append(i['Status'].value_counts()[0])\\n totalcomplaints.append(len(i))\\ncloseddf = pd.DataFrame()\\ncloseddf['Closed'] = closedcomplaints\\ncloseddf['Total'] = totalcomplaints\\npercent = []\\nfor i in range(len(closeddf)):\\n percent.append(closeddf['Closed'][i]\\/closeddf['Total'][i])\\ncloseddf['Percent'] = percent\\ncloseddf['Year'] = ['2010', '2011', '2012', '2013', '2014', '2015', '2016']\\ncloseddf = closeddf.set_index('Year')\\n\\nfig, ax1 = plt.subplots()\\ncloseddf['Percent'].plot(ax=ax1, kind='line', color='g', grid=True)\\nax1.set_title('Closed Complaints Percentage by Year', size=14)\\nax1.set_xlabel('Year')\\nax1.set_ylabel('Percent')\\nax1.legend(['Percent'], loc=0)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Assign each school to a census tract\\nThis is done by loading a file from the American Community Survey that contains the centroid (lat\\/lon) of each census tract. We then calculate Vincenty distance from each school to the centroids of each tract, and take the tract with the shortest distance. This method is not exact (it assumes uniformly shaped tracts), but it is pretty close and should always result in indentifying at least with a CLOSE census tract. Code takes ~1 min to run (Vincenty distance is slow)\\n\",\"targets\":\"# Load the file from ACS with centroids for each tract\\nfp_tract_centroids = os.path.join (bp_data, 'tract_centroids.txt')\\ndf_tracts = pd.read_csv (fp_tract_centroids)\\ndf_tracts = df_tracts.drop ([df_tracts.columns[0]], axis = 1) # Drop first column, unused\\n\\n# Build dictionary of GEOIDS (keys) and Lat \\/ Lon tuples (values)\\ntract_dict = {df_tracts.GEOID[i]: (df_tracts.LAT[i], df_tracts.LON[i]) \\\\\\n for i in range (0,len(df_tracts))}\\n\\n\\n# Assign the 50 closest tracts to each school, based on centroid distances \\ntract_list, dist_list = [],[] # Each element in these lists will be another n-element list\\nn = 50 # Use 20 closest tract centroids\\nfor lat, lon, name in zip (df_loc.LAT.tolist(), df_loc.LON.tolist(), df_loc.NAME):\\n loc_query = [lat, lon]\\n tracts, dists = find_closest_n_loc (tract_dict, loc_query, n)\\n tract_list.append (tracts) # Append a 20-element list to the list-of-lists\\n dist_list.append (dists) # Append a 20-element list to the list-of-lists\\n\\n# Add the geocode (name) of the 20 closest tracts to the dataframe\\ntract_array = np.array (tract_list)\\ncol_names_tract = ['GEOCODE' + str(i).zfill(2) for i in range (0,n)]\\nfor i in range (n):\\n df_loc ['GEOCODE' + str(i).zfill(2)] = tract_array[:,i]\\n \\ndf_loc.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Example of sub-class\\n\\nclass Add:\\n def __init__(self, num_1, num_2):\\n self.num_1 = num_1\\n self.num_2 = num_2\\n \\n def sum_all(self):\\n print(\\\"Method sum_all() in class A:\\\")\\n return self.num_1 + self.num_2\\n\\nclass Multiply(Add):\\n def mult_all(self):\\n print(\\\"Method mult_all() in class B:\\\")\\n return self.num_1 * self.num_2\\n\\n# Instance derived class Multiply(Add)\\nm = Multiply(10, 10)\\n\\n# Check if Multiply inherits Add\\ndisplay(issubclass(Multiply, Add))\\n\\n# Check if Add inherits Multiply\\ndisplay(issubclass(Add, Multiply))\\n\\n# Check if Add inherits itself\\ndisplay(issubclass(Add, Add))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nChecking for subclasses\\n- issubclass(class_A, class_B)\\n- You can use this to determine if one class inherits another class.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Data Collection\\nalpha = 0.1\\nsymbol_list = ['XLF', 'MCD']\\nstart = '2015-01-01'\\nend = '2016-01-01'\\npricing_sample = get_pricing(symbol_list, start_date = start, end_date = end, fields='price')\\npricing_sample.columns = map(lambda x: x.symbol, pricing_sample.columns)\\nreturns_sample = pricing_sample.pct_change()[1:]\\n\\n\\n# Sample mean values\\nmu_xlf, mu_gs = returns_sample.mean()\\ns_xlf, s_gs = returns_sample.std()\\nn_xlf = len(returns_sample['XLF'])\\nn_gs = len(returns_sample['MCD'])\\n\\ntest_statistic = ((mu_xlf - mu_gs) - 0)\\/((s_xlf**2\\/n_xlf) + (s_gs**2\\/n_gs))**0.5\\ndf = ((s_xlf**2\\/n_xlf) + (s_gs**2\\/n_gs))**2\\/ \\\\\\n (((s_xlf**2 \\/ n_xlf)**2 \\/(n_xlf-1))+((s_gs**2 \\/ n_gs)**2\\/(n_gs-1)))\\n\\nprint 't test statistic: ', test_statistic\\nprint 'Degrees of freedom (modified): ', df\\nprint 'p-value: ', 2 * (1 - t.cdf(test_statistic, df))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAs we can see above, our p-value is greater than our significant level, $\\\\alpha = 0.1$, we thus fail to reject the null hypothesis.\\n\\nExercise 3: Multiple Variables Tests.\\na. Hypothesis testing on Means.\\n\\nState the hypothesis tests for comparing two means\\nFind the test statistic along with the degrees of freedom for the following two assets. Assume variance is different (We assume XLF to be a safer buy than GS. \\nUse the t-table to conclude about your hypothesis test. Pick $\\\\alpha = 10\\\\%$\\n\\nUseful Formulas:\\n$$ t = \\\\frac{\\\\bar{X}_1 - \\\\bar{X}_2}{(\\\\frac{s_p^2}{n_1} + \\\\frac{s_p^2}{n_2})^{1\\/2}}$$\\n$$ t = \\\\frac{\\\\bar{X}_1 - \\\\bar{X}_2}{(\\\\frac{s_1^2}{n_1} + \\\\frac{s_2^2}{n_2})^{1\\/2}}$$\\n$$df = \\\\frac{(\\\\frac{s_1^2}{n_1} + \\\\frac{s_2^2}{n_2})^2}{(s_1^2\\/n_1)^2\\/(n_1-1) + (s_2^2\\/n_2)^2\\/(n_2-1)}$$\\nnote: one formula for t involves equal variance, the other does not. Use the right one given the information above\\n\\nAnswer: \\n\\nHypothesis Tests when comparing two means: \\n$$1. H_0: \\\\mu_1 - \\\\mu_2 = \\\\theta_0, \\\\ H_A: \\\\mu_1 - \\\\mu_2 \\\\neq \\\\theta_0$$\\n$$2. H_0: \\\\mu_1 - \\\\mu_2 \\\\leq \\\\theta_0, \\\\ H_A: \\\\mu_1 - \\\\mu_2 > \\\\theta_0$$\\n$$3. H_0: \\\\mu_1 - \\\\mu_2 \\\\geq \\\\theta_0, \\\\ H_A: \\\\mu_1 - \\\\mu_2 < \\\\theta_0$$\\n<\\/center>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Business Day Convention\\nThe pricing in Example 1 uses the modified following business day convention for the US for treasure payment dates. That is, if the coupon date falls on a weekend or holiday, it is paid on the following business day, unless said following business day falls into the next calendar month, in which case we go backwards to the nearest previous business day. It also provides functionality to generate regular coupon payments, before applying business day convention.\\n\",\"targets\":\"#@title Implement Business Day Convention\\ndef get_coupon_dates(current_date, maturity_date, months = 6):\\n # Compute sequence of dates `months` apart starting at maturity_date,\\n # working backwards to last one after current_date. \\n cashflow_dates = []\\n date = maturity_date\\n while date >= current_date:\\n cashflow_dates.append(date)\\n date = date + relativedelta(months=-months)\\n # Check if dates are on a US holiday or weekend\\n return pd.to_datetime(cashflow_dates).sort_values()\\n \\ndef get_modified_following_date(dates):\\n # Get the modified folliwng business day for the US. \\n BDayUS = CustomBusinessDay(calendar=USFederalHolidayCalendar(), n = 1) \\n def is_weekday(dates):\\n # Identify weekend days\\n return ~dates.weekday_name.isin(['Saturday', 'Sunday'])\\n\\n def in_next_month(dates1, dates2): \\n return dates1.month == dates2.month - 1\\n\\n def next_bus_day(dates):\\n # If next business day in a new month shift to previous business day\\n fwd = dates + BDayUS\\n return fwd.where(~in_next_month(dates, fwd), dates - BDayUS)\\n\\n def payment_day(dates):\\n return dates.where(is_weekday(dates), next_bus_day(dates))\\n return payment_day(dates)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Interpolation\\/.ipynb_checkpoints\\/InterpolationEx02-checkpoint.ipynb\\\".\\nThe first task is:\\nUse meshgrid and griddata to interpolate the function $f(x,y)$ on the entire square domain:\\n\\nxnew and ynew should be 1d arrays with 100 points between $[-5,5]$.\\nXnew and Ynew should be 2d versions of xnew and ynew created by meshgrid.\\nFnew should be a 2d array with the interpolated values of $f(x,y)$ at the points (Xnew,Ynew).\\nUse cubic spline interpolation.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nxnew = np.linspace(-5, 5, 100)\\nynew = np.linspace(-5, 5, 100)\\nXnew, Ynew = np.meshgrid(xnew, ynew)\\n\\nFnew = griddata((x,y), f, (Xnew, Ynew), method='cubic', fill_value=0.0)\\n\\nassert xnew.shape==(100,)\\nassert ynew.shape==(100,)\\nassert Xnew.shape==(100,100)\\nassert Ynew.shape==(100,100)\\nassert Fnew.shape==(100,100)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Checkpoint\\nThe model has been saved to disk.\\nTest Model\\nTest your model against the test dataset. This will be your final accuracy. You should have an accuracy greater than 50%. If you don't, keep tweaking the model architecture and parameters.\\n\",\"targets\":\"\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL\\n\\\"\\\"\\\"\\n%matplotlib inline\\n%config InlineBackend.figure_format = 'retina'\\n\\nimport tensorflow as tf\\nimport pickle\\nimport helper\\nimport random\\n\\n# Set batch size if not already set\\ntry:\\n if batch_size:\\n pass\\nexcept NameError:\\n batch_size = 64\\n\\nsave_model_path = '.\\/image_classification'\\nn_samples = 4\\ntop_n_predictions = 3\\n\\ndef test_model():\\n \\\"\\\"\\\"\\n Test the saved model against the test dataset\\n \\\"\\\"\\\"\\n\\n test_features, test_labels = pickle.load(open( cifar10_dataset_folder_path + '\\/preprocess_training.p', mode='rb'))\\n loaded_graph = tf.Graph()\\n\\n with tf.Session(graph=loaded_graph) as sess:\\n # Load model\\n loader = tf.train.import_meta_graph(save_model_path + '.meta')\\n loader.restore(sess, save_model_path)\\n\\n # Get Tensors from loaded model\\n loaded_x = loaded_graph.get_tensor_by_name('x:0')\\n loaded_y = loaded_graph.get_tensor_by_name('y:0')\\n loaded_keep_prob = loaded_graph.get_tensor_by_name('keep_prob:0')\\n loaded_logits = loaded_graph.get_tensor_by_name('logits:0')\\n loaded_acc = loaded_graph.get_tensor_by_name('accuracy:0')\\n \\n # Get accuracy in batches for memory limitations\\n test_batch_acc_total = 0\\n test_batch_count = 0\\n \\n for train_feature_batch, train_label_batch in helper.batch_features_labels(test_features, test_labels, batch_size):\\n test_batch_acc_total += sess.run(\\n loaded_acc,\\n feed_dict={loaded_x: train_feature_batch, loaded_y: train_label_batch, loaded_keep_prob: 1.0})\\n test_batch_count += 1\\n\\n print('Testing Accuracy: {}\\\\n'.format(test_batch_acc_total\\/test_batch_count))\\n\\n # Print Random Samples\\n random_test_features, random_test_labels = tuple(zip(*random.sample(list(zip(test_features, test_labels)), n_samples)))\\n random_test_predictions = sess.run(\\n tf.nn.top_k(tf.nn.softmax(loaded_logits), top_n_predictions),\\n feed_dict={loaded_x:...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"By default, the run_metrics class loads all the InterOp files.\\n\\nrun_folder = run_metrics.read(run_folder)\\n\\nThe InterOp library can provide a list of all necessary InterOp files for a specific application. The following shows how to generate that list for the index summary statistics:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nvalid_to_load = py_interop_run.uchar_vector(py_interop_run.MetricCount, 0)\\n\\npy_interop_run_metrics.list_index_metrics_to_load(valid_to_load)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Perevedentsev\\/tensorflow.ipynb\\\".\\nThe first task is:\\nBasic usage\\nLaunch the default graph\\nTo run the matmul op we call the session 'run()' method, passing 'product'\\nwhich represents the output of the matmul op. This indicates to the call\\nthat we want to get the output of the matmul op back.\\nAll inputs needed by the op are run automatically by the session. They\\ntypically are run in parallel.\\nThe call 'run(product)' thus causes the execution of threes ops in the\\ngraph: the two constants and matmul.\\nThe output of the op is returned in 'result' as a numpy ndarray object.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport tensorflow as tf\\n\\nwith tf.Graph().as_default():\\n # Create a Constant op that produces a 1x2 matrix. The op is\\n # added as a node to the default graph.\\n #\\n # The value returned by the constructor represents the output\\n # of the Constant op.\\n matrix1 = tf.constant([[3., 3.]])\\n\\n # Create another Constant that produces a 2x1 matrix.\\n matrix2 = tf.constant([[2.],[2.]])\\n\\n # Create a Matmul op that takes 'matrix1' and 'matrix2' as inputs.\\n # The returned value, 'product', represents the result of the matrix\\n # multiplication.\\n product = tf.matmul(matrix1, matrix2)\\n with tf.Session() as sess:\\n result = sess.run([product])\\n print(result)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2_kmeans-with-text-data_blank.ipynb\\\".\\nThe first task is:\\nHow to choose K\\nSince we are measuring the tightness of the clusters, a higher value of K reduces the possible heterogeneity metric by definition. For example, if we have N data points and set K=N clusters, then we could have 0 cluster heterogeneity by setting the N centroids equal to the values of the N data points. (Note: Not all runs for larger K will result in lower heterogeneity than a single run with smaller K due to local optima.) Let's see explore this general trend for ourselves by performing the following analysis.\\nUse the kmeans_multiple_runs function to run k-means with five different values of K. For each K, use k-means++ and multiple runs to pick the best solution. In what follows, we consider K=2,10,25,50,100 and 7 restarts for each setting.\\nIMPORTANT: The code block below will take about one hour to finish. We highly suggest that you use the arrays that we have computed for you.\\nSide note: In practice, a good implementation of k-means would utilize parallelism to run multiple runs of k-means at once. For an example, see scikit-learn's KMeans.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#def plot_k_vs_heterogeneity(k_values, heterogeneity_values):\\n# plt.figure(figsize=(7,4))\\n# plt.plot(k_values, heterogeneity_values, linewidth=4)\\n# plt.xlabel('K')\\n# plt.ylabel('Heterogeneity')\\n# plt.title('K vs. Heterogeneity')\\n# plt.rcParams.update({'font.size': 16})\\n# plt.tight_layout()\\n\\n#start = time.time()\\n#centroids = {}\\n#cluster_assignment = {}\\n#heterogeneity_values = []\\n#k_list = [2, 10, 25, 50, 100]\\n#seed_list = [0, 20000, 40000, 60000, 80000, 100000, 120000]\\n\\n#for k in k_list:\\n# heterogeneity = []\\n# centroids[k], cluster_assignment[k] = kmeans_multiple_runs(tf_idf, k, maxiter=400,\\n# num_runs=len(seed_list),\\n# seed_list=seed_list,\\n# verbose=True)\\n# score = compute_heterogeneity(tf_idf, k, centroids[k], cluster_assignment[k])\\n# heterogeneity_values.append(score)\\n\\n#plot_k_vs_heterogeneity(k_list, heterogeneity_values)\\n\\n#end = time.time()\\n#print(end-start)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"BEM_problem.ipynb\\\".\\nThe first task is:\\nBoundary element implementation\\n\\nFigure 2. Representation of a local gridblock with boundary elements<\\/center>\\nGenerally, the influence of all the j panels on the i BE node can be expressed as follows:\\n\\\\begin{matrix}\\n{{c}{ij}}{{p}{i}}+{{p}{i}}\\\\int{{{s}{j}}}{{{H}{ij}}d{{s}{j}}}=({{v}{i}}\\\\cdot \\\\mathbf{n})\\\\int_{{{s}{j}}}{{{G}{ij}}}d{{s}_{j}}\\n\\\\end{matrix}\\nWhere,\\n${{c}_{ij}}$ is the free term, cased by source position.\\n${{c}_{ij}}=\\\\left{ \\\\begin{matrix}\\n \\\\begin{matrix}\\n 1 & \\\\text{source j on the internal domain} \\\\\\n\\\\end{matrix} \\\\\\n \\\\begin{matrix}\\n 0.5 & \\\\text{source j on the boundary} \\\\\\n\\\\end{matrix} \\\\\\n \\\\begin{matrix}\\n 0 & \\\\text{source j on the external domain} \\\\\\n\\\\end{matrix} \\\\\\n\\\\end{matrix} \\\\right.$<\\/center>\\n$\\\\int_{{{s}{j}}}{{{H}{ij}}d{{s}_{j}}\\\\text{ }}$ is the integrated effect of the boundary element source i on the resulting normal flux at BE node j. \\n$\\\\int_{{{s}{j}}}{{{G}{ij}}}d{{s}_{j}}$ is the is the integrated effect of the boundary element source i on the resulting pressure at BE node j\\nLine segment source solution for pressure and velocity (Derived recently)\\nThe integrated effect can be formulated using line segment source solution, which givs:\\n\\\\begin{equation}\\n\\\\int_{{{s}{j}}}{{{G}{ij}}}d{{s}{j}}=B{{Q}{w}}=P({{{x}'}{i}},{{{y}'}{i}})=-\\\\frac{70.60\\\\mu }{h\\\\sqrt{{{k}{x}}{{k}{y}}}}\\\\int_{t=0}^{t={{l}{j}}}{\\\\ln \\\\left{ {{({x}'-t\\\\cos {{\\\\alpha }{j}})}^{2}}+\\\\frac{{{k}{x}}}{{{k}{y}}}{{({y}'-t\\\\sin {{\\\\alpha }{j}})}^{2}} \\\\right}dt}\\\\cdot {{Q}{w}}\\n\\\\end{equation}\\n\\\\begin{equation}\\n\\\\int_{{{s}{j}}}{{{H}{ij}}d{{s}{j}}\\\\text{ }}={{v}{i}}(s)\\\\cdot {{\\\\mathbf{n}}{i}}=-{{u}{i}}\\\\sin {{\\\\alpha }{i}}+{{v}{i}}\\\\cos {{\\\\alpha }_{i}}\\n\\\\end{equation}\\nWhere,\\n\\\\begin{equation}\\nu\\\\left( {{{{x}'}}{i}},{{{{y}'}}{i}} \\\\right)={{A}{u}}{{Q}{j}}=\\\\frac{0.8936}{h\\\\phi }\\\\sqrt{\\\\frac{{{k}{x}}}{{{k}{y}}}}\\\\int_{t=0}^{t={{l}{j}}}{\\\\frac{{{{{x}'}}{i}}-t\\\\cos {{\\\\alpha }{j}}}{{{\\\\left( {{{{x}'}}{i}}-t\\\\cos {{\\\\alpha }{j}} \\\\right)}^{2}}+\\\\frac{{{k}{x}}}{{{k}{y}}}{{({{{{y}'}}{i}}-t\\\\sin {{\\\\alpha...\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#Panel infuence factor Bij\\ndef InflueceP(x, y, panel):\\n \\\"\\\"\\\"Evaluates the contribution of a panel at one point.\\n \\n Arguments\\n ---------\\n x, y -- Cartesian coordinates of the point.\\n panel -- panel which contribution is evaluated.\\n \\n Returns\\n -------\\n Integral over the panel of the influence at one point.\\n \\\"\\\"\\\"\\n#Transfer global coordinate point(x,y) to local coordinate\\n x=x-panel.xa\\n y=y-panel.ya\\n L1=panel.length\\n \\n#Calculate the pressure and velocity influence factor\\n a=panel.cosalpha**2+kr*panel.sinalpha**2\\n b=x*panel.cosalpha+kr*panel.sinalpha*y\\n c=y*panel.cosalpha-x*panel.sinalpha\\n dp=70.6*miu\\/h\\/math.sqrt(kx*ky)\\n Cp = dp\\/a*(\\n (\\n b*math.log(x**2-2*b*L1+a*L1**2+kr*y**2)\\n -L1*a*math.log((x-L1*panel.cosalpha)**2+kr*(y-L1*panel.sinalpha)**2)\\n +2*math.sqrt(kr)*c*math.atan((b-a*L1)\\/math.sqrt(kr)\\/c)\\n )\\n -\\n (\\n b*math.log(x**2+kr*y**2)\\n +2*math.sqrt(kr)*c*math.atan((b)\\/math.sqrt(kr)\\/c)\\n ) \\n )\\n #debug\\n #print(\\\"a: %s b:%s c:%s \\\" % (a,b,c))\\n #angle=math.atan((b-a*L1)\\/math.sqrt(kr)\\/c)*180\\/numpy.pi\\n #print(\\\"Magic angle:%s\\\"% angle)\\n return Cp\\n\\ndef InflueceU(x, y, panel):\\n \\\"\\\"\\\"Evaluates the contribution of a panel at one point.\\n \\n Arguments\\n ---------\\n x, y -- Cartesian coordinates of the point.\\n panel -- panel which contribution is evaluated.\\n \\n Returns\\n -------\\n Integral over the panel of the influence at one point.\\n \\\"\\\"\\\"\\n#Transfer global coordinate point(x,y) to local coordinate\\n x=x-panel.xa\\n y=y-panel.ya\\n L1=panel.length\\n\\n#Calculate the pressure and velocity influence factor\\n a=panel.cosalpha**2+kr*panel.sinalpha**2\\n b=x*panel.cosalpha+kr*panel.sinalpha*y\\n c=y*panel.cosalpha-x*panel.sinalpha\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"! curl https:\\/\\/packages.cloud.google.com\\/apt\\/doc\\/apt-key.gpg | sudo apt-key add -\\n\\n! echo \\\"deb https:\\/\\/packages.cloud.google.com\\/apt coral-edgetpu-stable main\\\" | sudo tee \\/etc\\/apt\\/sources.list.d\\/coral-edgetpu.list\\n\\n! sudo apt-get update\\n\\n! sudo apt-get install edgetpu-compiler\\t\\n\\n! edgetpu_compiler weather_forecast_quant.tflite\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIf you compare these predictions from the quantized model to those we got from the float Keras model above, they're not very different.\\nCompile for the Edge TPU\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"9- Quais São os Top 10 Melhores Filmes?\\nTop 10 filmes com melhor avaliação e mais de 25 mil votos.\\n\",\"targets\":\"# Consulta SQL\\nconsulta9 = '''\\n SELECT primary_title AS Movie_Name, genres, rating\\n FROM \\n titles JOIN ratings\\n ON titles.title_id = ratings.title_id\\n WHERE titles.type = 'movie' AND ratings.votes >= 25000\\n ORDER BY rating DESC\\n LIMIT 10 \\n ''' \\n\\n# Resultado\\ntop10_melhores_filmes = pd.read_sql_query(consulta9, conn)\\n\\ndisplay(top10_melhores_filmes)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"20161110-twitter-interaction\\/interactions.ipynb\\\".\\nThe first task is:\\nThis demonstrates that the following are available from the user timeline:\\n* retweets by the user\\n* quotes by the user\\n* replies by the user\\n* favorited tweets\\n* retweeted tweets\\nOther than the counts for favorited tweets and retweeted tweets, it does not include the tweets of other users such as quotes of this user or replies to tweets of this user.\\nGET statuses\\/retweets\\/:id\\nGET statuses\\/retweets\\/:id returns the most recent retweets for a tweet. Only the most recent 100 retweets are available.\\nTo test this, let's compare the retweet_count against the number of tweets returned by GET statuses\\/retweets\\/:id for that tweet.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntweet = list(t.hydrate(['743520583518920704']))[0]\\nprint \\\"The retweet count is {}\\\".format(tweet['retweet_count'])\\nretweets = t.retweets('743520583518920704')\\nprint \\\"Retrieved {} retweets\\\".format(len(list(retweets)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"PyDSTool\\/PyDSTool_Introduction.ipynb\\\".\\nThe first task is:\\nThis code highlights the utility of the 'trajectory' object. We can use this object as a parametric function. Indeed it interpolates between independent variables automatically. In our example $5.4$ was not in the 'time set'.\\nCan you write Python code for it?\\n\",\"targets\":\"\\npts.find(5.4)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Comment:\\nThis is interesting, we see that the sentences have some sort of sense, but when we reach a point, we see the same sentence repated many times. Thus is probably due to overfitting, we should look more deeply. We see that the repeated sentence is different from the original one, but it is still always the same. We think this is due to the fact that the dot start always the same sentence. Maybe we could create more layers and see what happens.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef load_data(filename):\\n with open(filename) as f:\\n data = f.readlines()\\n data = [x.strip().lower() for x in data]\\n data = [data[i].split() for i in range(len(data))]\\n data = np.array(data)\\n data = np.reshape(data, [-1, ])\\n return data\\n\\ntrain_file ='data\\/story.txt'\\ntrain_data = load_data(train_file)\\n\\ndef build_vocabulary(words):\\n count = collections.Counter(words).most_common()\\n dic= dict()\\n for word, _ in count:\\n dic[word] = len(dic)\\n\\n reverse_dic= dict(zip(dic.values(), dic.keys()))\\n return dic, reverse_dic\\n\\ndictionary, reverse_dictionary = build_vocabulary(train_data)\\nvocabulary_size= len(dictionary) \\n\\nimport numpy as np\\nimport collections # used to build the dictionary\\nimport random\\nimport time\\nfrom time import time\\nimport pickle # may be used to save your model \\nimport matplotlib.pyplot as plt\\n#Import Tensorflow and rnn\\nimport tensorflow as tf\\nfrom tensorflow.contrib import rnn \\n\\ndef create_train_model(n_input = 3, n_layers = 2,verbose = False):\\n tf.reset_default_graph()\\n # Target log path\\n logs_path = 'lstm_words'\\n writer = tf.summary.FileWriter(logs_path)\\n \\n def lstm_model(x, w, b, n_input, n_hidden,n_layers):\\n # reshape to [1, n_input]\\n x = tf.reshape(x, [-1, n_input])\\n\\n # Generate a n_input-element sequence of inputs\\n # (eg. [had] [a] [general] -> [20] [6] [33])\\n x = tf.split(x,n_input,1)\\n\\n rnn_layers = [rnn.BasicLSTMCell(n_hidden) for _ in range(n_layers)]\\n rnn_cell = rnn.MultiRNNCell(rnn_layers)\\n # generate prediction\\n outputs, states = rnn.static_rnn(rnn_cell, x, dtype=tf.float32)\\n\\n # there are n_input outputs but\\n # we only want the last output\\n return tf.matmul(outputs[-1], w['out']) + b['out']\\n \\n # Training Parameters\\n learning_rate = 0.001\\n epochs = 50000\\n display_step = 1000\\n\\n\\n #For each LSTM cell that you initialise, supply a value for the hidden dimension, number of units in LSTM cell\\n n_hidden = 64\\n\\n # tf Graph input\\n...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Configure gcloud and add kfctl to your path.\\n\",\"targets\":\"! gcloud config set project ${PROJECT}\\n\\n! gcloud config set compute\\/zone ${ZONE}\\n\\n\\n# Set the path to the base directory where you want to store one or more \\n# Kubeflow deployments. For example, \\/opt\\/.\\n# Here we use the current working directory as the base directory\\n# Then set the Kubeflow application directory for this deployment.\\n\\nimport os\\nbase = os.getcwd()\\n%env BASE_DIR=$base\\n\\nkf_dir = os.getenv('BASE_DIR') + \\\"\\/\\\" + os.getenv('KF_NAME')\\n%env KF_DIR=$kf_dir\\n\\n# The following command is optional. It adds the kfctl binary to your path.\\n# If you don't add kfctl to your path, you must use the full path\\n# each time you run kfctl. In this example, the kfctl file is present in\\n# the current directory\\nnew_path = os.getenv('PATH') + \\\":\\\" + os.getenv('BASE_DIR')\\n%env PATH=$new_path\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"HW2.ipynb\\\".\\nThe first task is:\\nEvaluating and Validating our Forecast\\nThe point of creating a probabilistic predictive model is to simultaneously make a forecast and give an estimate of how certain we are about it. \\nHowever, in order to trust our prediction or our reported level of uncertainty, the model needs to be correct. We say a model is correct if it honestly accounts for all of the mechanisms of variation in the system we're forecasting.\\nIn this section, we evaluate our prediction to get a sense of how useful it is, and we validate the predictive model by comparing it to real data.\\n1.4 Suppose that we believe the model is correct. Under this assumption, we can evaluate our prediction by characterizing its accuracy and precision (see here for an illustration of these ideas). What does the above plot reveal about the accuracy and precision of the PredictWise model?\\nYour Answer Here\\n1.5 Unfortunately, we can never be absolutely sure that a model is correct, just as we can never be absolutely sure that the sun will rise tomorrow. But we can test a model by making predictions assuming that it is true and comparing it to real events -- this constitutes a hypothesis test. After testing a large number of predictions, if we find no evidence that says the model is wrong, we can have some degree of confidence that the model is right (the same reason we're still quite confident about the sun being here tomorrow). We call this process model checking, and use it to validate our model.\\nDescribe how the graph provides one way of checking whether the prediction model is correct. How many predictions have we checked in this case? How could we increase our confidence in the model's correctness?\\nYour Answer Here\\nGallup Party Affiliation Poll\\nNow we will try to estimate our own win probabilities to plug into our predictive model.\\nWe will start with a simple forecast model. We will try to predict the outcome of the election based the estimated proportion of people in each state who identify with one one political party or the other.\\nGallup measures the...\\nCan you write Python code for it?\\n\",\"targets\":\"\\ngallup_2012=pd.read_csv(\\\"data\\/g12.csv\\\").set_index('State')\\ngallup_2012[\\\"Unknown\\\"] = 100 - gallup_2012.Democrat - gallup_2012.Republican\\ngallup_2012.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1) Input shape\\nHow well can we predict a wine's perceived quality from the physiochemical measurements? \\nThe target is 'quality', and the remaining columns are the features. How would you set the input_shape parameter for a Keras model on this task?\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# YOUR CODE HERE\\ninput_shape = ____\\n\\n# Check your answer\\nq_1.check()\\n\\n#%%RM_IF(PROD)%%\\ninput_shape = [12]\\nq_1.assert_check_failed()\\n\\n#%%RM_IF(PROD)%%\\ninput_shape = 11\\nq_1.assert_check_failed()\\n\\n#%%RM_IF(PROD)%%\\ninput_shape = [11]\\nq_1.assert_check_passed()\\n\\n# Lines below will give you a hint or solution code\\n#_COMMENT_IF(PROD)_\\nq_1.hint()\\n#_COMMENT_IF(PROD)_\\nq_1.solution()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Das Code Check.ipynb\\\".\\nThe first task is:\\nWriting to file...it does not want things delmited by a comma\\nAlso, no lists or anything, just new lines for a new word-vector or new document\\nCan you write Python code for it?\\n\",\"targets\":\"\\nwith open(\\\"\\/Users\\/michael\\/Documents\\/GaussianLDA\\/dasnips.txt\\\", 'w') as f:\\n for doc in index_corpus:\\n# f.write(str(doc).replace(\\\"[\\\", \\\"\\\").replace(\\\"]\\\",\\\"\\\") + \\\"\\\\n\\\")\\n for word in doc:\\n f.write(str(word) + \\\" \\\")\\n f.write(\\\"\\\\n\\\")\\n\\n# lazy way of creating file that did not exist before\\nwith open(\\\"\\/Users\\/michael\\/Documents\\/GaussianLDA\\/dasnips_vecs50.txt\\\", 'w') as f:\\n None\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# add `echo=True` to see log statements of all the SQL that is generated\\nengine = create_engine('sqlite:\\/\\/\\/:memory:',echo=True) # just save the db in memory for now (ie. not on disk)\\nmetadata = MetaData()\\n# define a table to use\\nqueries = Table('query', metadata,\\n Column('id', Integer, primary_key=True),\\n Column('keywords', String(400), nullable=False),\\n Column('timestamp', DateTime, default=datetime.datetime.now),\\n)\\nmetadata.create_all(engine) # and create the tables in the database\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nBasic SQL Generation\\nThe core library generates SQL for you. Read more about it on their expression language tutorial page. Below are some basic examples.\\nCreating a Table\\nRead more about defining and creating tables.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Accessing attributes in grid-searched pipeline.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.linear_model import LogisticRegression\\n\\npipe = make_pipeline(StandardScaler(), LogisticRegression())\\n\\nparam_grid = {'logisticregression__C': [0.01, 0.1, 1, 10, 100]}\\n\\nX_train, X_test, y_train, y_test = train_test_split(\\n cancer.data, cancer.target, random_state=4)\\ngrid = GridSearchCV(pipe, param_grid, cv=5)\\ngrid.fit(X_train, y_train)\\n\\nprint(grid.best_estimator_)\\n\\nprint(grid.best_estimator_.named_steps[\\\"logisticregression\\\"])\\n\\nprint(grid.best_estimator_.named_steps[\\\"logisticregression\\\"].coef_)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"CabinとTicketのカラムは削除してしまいましょう。\\n\",\"targets\":\"df.drop(['Ticket', 'Cabin'], axis=1, inplace=True)\\n\\ndf.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapman\\/Ch1-Problem_1-05.ipynb\\\".\\nThe first task is:\\nand the magnetomotive force required to produce a flux of 0.005 Wb is $\\\\mathcal{F} = \\\\phi \\\\mathcal{R}_\\\\text{TOT}$:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nF = phi * Rtot\\nprint('F = {:.1f} At'.format(F) )\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%timeit optimise_rapide(nuage, 0, len(nuage))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nC'est carrément plus rapide et cela marche pour toute fonction fct.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"(3d) Perform action count to view counts \\nOne of the most basic jobs that we can run is the count() job which will count the number of elements in an RDD using the count() action. Since map() creates a new RDD with the same number of elements as the starting RDD, we expect that applying count() to each RDD will return the same result.\\nNote that because count() is an action operation, if we had not already performed an action with collect(), then Spark would now perform the transformation operations when we executed count().\\nEach task counts the entries in its partition and sends the result to your SparkContext, which adds up all of the counts. The figure below shows what would happen if we ran count() on a small example dataset with just four partitions.\\n\",\"targets\":\"print xrangeRDD.count()\\nprint subRDD.count()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"8.4 The Adwords Problem\\n8.4.1 History of Search Advertsing\\n\\n\\nGoogle would show only a limited number of ads with each query.\\n\\n\\nUsers of the Adwords system specified a budge.\\n\\n\\nGoogle did not simply order ads by the amount of the bid, but by the amount they expected to receive for display of each ad.\\n\\n\\n8.4.2 Definition of the Adwords Problem\\nGiven:\\n\\n\\nA set of bids by advertisers for search queries.\\n\\n\\nA click-through rate for each advertiser-query pair.\\n\\n\\nA budge for each advertiser.\\n\\n\\nA limit on the nuber of ads to be displayed with each search query.\\n\\n\\nRespond to each search query with a set of advertisers such that:\\n\\n\\nThe size of the set is no larger than the limit on the number of ads per query.\\n\\n\\nEach advertiser has bid on the search query.\\n\\n\\nEach advertiser has enough budget left to pay for the ad if it is clicked upon.\\n\\n\\nThe revenue of a selection of ads is the total value of the ads selected, where the value of an ad is the product of the bid and the click-through rate for the ad and query.\\n8.4.3 The Greedy Approach to the Adwords Problem\\nMake some simplifications:\\n\\n\\nThere is one ad shown for each query.\\n\\n\\nAll advertisers have the same budget.\\n\\n\\nAll click-through rates are the same.\\n\\n\\nAll bids are either 0 or 1.\\n\\n\\nThe greddy algorithm picks, for each search query, any advertiser who has bid 1 for that query.\\ncompetitive ratio for this algorithm is 1\\/2. It's similar with 8.3.3.\\n8.4.4 The Balance Algorithm\\nThe Balance algorithm assigns a query to the advertiser who bids on the query and has the largest remaining budget.\\n8.4.5 A Lower Bound on Competitive Ratio for Balance\\nWith only two advertisers, $3\\/4$ is exactly the competitive ratio.\\nLet two advertisers $A_1$ and $A_2$ have a same budget of $B$. We assume:\\n\\n\\neach query is assigned to an advertiser by the optimum algorithm. \\n if not, we can delete those queries without affecting the revenue of the optimum algorithm and possibly reducing the revenue of Balance.\\n\\n\\nboth advertisers' budgets are consumed by the optimum algorithm. \\n If not, we can...\\n\",\"targets\":\"plt.imshow(plt.imread('.\\/res\\/fig8_3.png'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapman\\/Ch8-Problem_8-10to11.ipynb\\\".\\nThe first task is:\\nThe equivalent field current is:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nIf_11_ = If_11 + Nse\\/Nf * Ia_11\\nIf_11_\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Array Creation Functions\\n\\narange\\nlinspace, logspace\\nzeros, ones\\nrand, randn\\ntile\\n\",\"targets\":\"a = np.arange(10) # 0 .. n-1 (!)\\na\\n\\nb = np.arange(1, 9, 2) # start, end (exclusive), step\\nb\\n\\nc = np.linspace(0, 1, 6) # start, end, num-points\\nc\\n\\nd = np.linspace(0, 1, 5, endpoint=False)\\nd\\n\\na = np.ones((3, 3)) # reminder: (3, 3) is a tuple\\na\\n\\nb = np.zeros((2,2))\\nb\\n\\nc = np.diag([1,2,3])\\nc\\n\\nd = np.eye(4)\\nd\\n\\na = np.array([0,1,2])\\na\\n\\nnp.tile(a, 2)\\n\\nnp.tile(a, (3,2)), (np.tile(a, (3,2))).ndim, (np.tile(a, (3,2))).shape\\n\\nnp.tile(a, (2,1,2)), np.tile(a, (2,1,2)).ndim, np.tile(a, (2,1,2)).shape\\n\\nb = np.array([[1,2], [3,4]])\\nb\\n\\nb.shape\\n\\nnp.tile(b, 2)\\n\\nnp.tile(b, (2, 1))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"$\\\\beta$-CsCl ($Fm\\\\overline{3}m$)\\nLet's now look at the $\\\\beta$ (high-temperature) form of CsCl.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Create CsCl structure\\na = 6.923 #Angstrom\\nlatt = Lattice.cubic(a)\\nstructure = Structure(latt, [\\\"Cs\\\", \\\"Cs\\\", \\\"Cs\\\", \\\"Cs\\\", \\\"Cl\\\", \\\"Cl\\\", \\\"Cl\\\", \\\"Cl\\\"], \\n [[0, 0, 0], [0.5, 0.5, 0], [0, 0.5, 0.5], [0.5, 0, 0.5], \\n [0.5, 0.5, 0.5], [0, 0, 0.5], [0, 0.5, 0], [0.5, 0, 0]])\\n\\nc.show_xrd_plot(structure)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\n Exercise 3a<\\/h1>\\n<\\/div>\\n\\nThe timeseries below was generated by a linear function of time, $y(t)= mt + b$. In addition to observational uncertainty $\\\\sigma$ (white noise), there is a fair bit of correlated (red) noise, which we will assume is well described\\nby the squared exponential covariance with a certain (unknown) amplitude $A$ and timescale $l$.\\nYour task is to estimate the values of $m$ and $b$, the slope and intercept of the line, respectively. In this part of the exercise, assume there is no correlated noise. Your model for the $n^\\\\mathrm{th}$ datapoint is thus\\n$$\\n\\\\begin{align}\\n y_n \\\\sim \\\\mathcal{N}(m t_n + b, \\\\sigma_n\\\\mathbf{I})\\n\\\\end{align}\\n$$\\nand the probability of the data given the model can be computed by calling your GP likelihood function:\\npython\\ndef lnprob(params):\\n m, b = params\\n model = m * t + b\\n return ln_gp_likelihood(t, y - model, sigma, A=0, l=1)\\nNote, importantly, that we are passing the residual vector, $y - (mt + b)$, to the GP, since above we coded up a zero-mean Gaussian process. We are therefore using the GP to model the residuals of the data after applying our physical model (the equation of the line).\\nTo estimate the values of $m$ and $b$ we could generate a fine grid in those two parameters and compute the likelihood at every point. But since we'll soon be fitting for four parameters (in the next part), we might as well upgrade our inference scheme and use the emcee package to do Markov Chain Monte Carlo (MCMC). If you haven't used emcee before, check out the first few tutorials on the documentation page. The basic setup for the problem is this:\\n```python\\nimport emcee\\nsampler = emcee.EnsembleSampler(nwalkers, ndim, lnprob)\\ninitial = [4.0, 15.0]\\np0 = initial + 1e-3 * np.random.randn(nwalkers, ndim)\\nprint(\\\"Running burn-in...\\\")\\np0, _, _ = sampler.run_mcmc(p0, nburn) # nburn = 500 should do\\nsampler.reset()\\nprint(\\\"Running...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nt, y, sigma = np.loadtxt(\\\"data\\/sample_data_line.txt\\\", unpack=True)\\nm_true, b_true, A_true, l_true = np.loadtxt(\\\"data\\/sample_data_line_truths.txt\\\", unpack=True)\\nplt.errorbar(t, y, yerr=sigma, fmt=\\\"k.\\\", label=\\\"observed\\\")\\nplt.plot(t, m_true * t + b_true, color=\\\"C0\\\", label=\\\"truth\\\")\\nplt.legend(fontsize=12)\\nplt.xlabel(\\\"time\\\")\\nplt.ylabel(\\\"data\\\");\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# The map projection capabilities come from the cartopy package. There are many possible projections\\nimport cartopy.crs as ccrs\\n\\ndef make_map(field):\\n '''input field should be a 2D xarray.DataArray on a lat\\/lon grid.\\n Make a filled contour plot of the field, and a line plot of the zonal mean\\n '''\\n fig = plt.figure(figsize=(14,6))\\n nrows = 10; ncols = 3\\n mapax = plt.subplot2grid((nrows,ncols), (0,0), colspan=ncols-1, rowspan=nrows-1, projection=ccrs.Robinson())\\n barax = plt.subplot2grid((nrows,ncols), (nrows-1,0), colspan=ncols-1)\\n plotax = plt.subplot2grid((nrows,ncols), (0,ncols-1), rowspan=nrows-1)\\n cx = mapax.contourf(field.lon, field.lat, field, transform=ccrs.PlateCarree())\\n mapax.set_global(); mapax.coastlines();\\n plt.colorbar(cx, cax=barax, orientation='horizontal')\\n plotax.plot(field.mean(dim='lon'), field.lat)\\n plotax.set_ylabel('Latitude')\\n plotax.grid()\\n return fig, (mapax, plotax, barax), cx\\n\\n# Plot a single time slice of surface air temperature just as example\\nfig, axes, cx = make_map(atm['cpl_control'].TREFHT.isel(time=0))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSome CMIP climate sensitivity results to compare against\\n\\n\\nComparing against the multi-model mean of the ECS and TCR, our model is apparently slightly less sensitive than the CMIP5 mean.\\nLet's make some maps to compare spatial patterns of transient vs. equilibrium warming\\nHere is a helper function that takes a 2D lat\\/lon field and renders it as a nice contour map with accompanying zonal average line plot.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Project 2\\/dlnd_image_classification.ipynb\\\".\\nThe first task is:\\nFully-Connected Layer\\nImplement the fully_conn function to apply a fully connected layer to x_tensor with the shape (Batch Size, num_outputs). Shortcut option: you can use classes from the TensorFlow Layers or TensorFlow Layers (contrib) packages for this layer. For more of a challenge, only use other TensorFlow packages.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef fully_conn(x_tensor, num_outputs):\\n \\\"\\\"\\\"\\n Apply a fully connected layer to x_tensor using weight and bias\\n : x_tensor: A 2-D tensor where the first dimension is batch size.\\n : num_outputs: The number of output that the new tensor should be.\\n : return: A 2-D tensor where the second dimension is num_outputs.\\n \\\"\\\"\\\"\\n weights = tf.Variable(tf.random_normal([x_tensor.get_shape().as_list()[1],num_outputs],stddev=0.1))\\n bias = tf.Variable(tf.zeros(num_outputs,dtype=tf.float32))\\n \\n fc_layer = tf.add(tf.matmul(x_tensor, weights), bias)\\n fc_layer = tf.nn.relu(fc_layer)\\n return fc_layer\\n\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_fully_conn(fully_conn)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\" \\n\\nExercise 2 End.<\\/b>\\n<\\/div>\\n\\n\\nExercise complete:\\nThis is a good time to \\\"Save and Checkpoint\\\".\\n\\n \\n\\nExercise 3 [Advanced] Start.<\\/b>\\n<\\/div>\\n\\n\\n\\nNote<\\/b>: \\nThis activity is for advanced students only and extra credit will be allocated. Students will not be penalized for not completing this activity.\\n<\\/div>\\n\\nInstructions\\n\\n\\n\\nUsing the \\\"dt.dayofweek()\\\" Pandas method, find the days of the week with most and least occurences of the access point you identified in Exercise 2.1 above. In your answer, provide both the days and corresponding number of occurrences of the access point on those days.\\n\\nHint: You will need to use the \\\"dt.dayofweek()\\\" series method on a datetime Pandas series object, which has been filtered to only contain instances of the identified access point.\\n\\n\\n\\nDescribe and explain the trend you observe regarding access point occurrences during the week, and whether or not it is similar to the behavior you would have expected.\\n\\nHint: To view the trend, use the Pandas \\\"plot(kind='bar')\\\" on the series object containing the counts of access point occurrences during the week.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Your answer here.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Additional keyword arguments give more control on centering and positioning, and you can pass a list of [color_negative, color_positive] to highlight lower and higher values.\\nHere's how you can change the above with the new align option, combined with setting vmin and vmax limits, the width of the figure, and underlying css props of cells, leaving space to display the text and the bars:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndf2.style.bar(align=0, vmin=-2.5, vmax=2.5, color=['#d65f5f', '#5fba7d'],\\n width=60, props=\\\"width: 120px; border-right: 1px solid black;\\\").format('{:.3f}', na_rep=\\\"\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"But a more less verbose and quicker approach would be:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncondition = (a > -90) & (a < -40)\\ncondition\\n\\nresult[condition] = a[condition]**2\\nresult[~condition] = 1\\nprint(result)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"BGS\\n\",\"targets\":\"from desitarget.mock.mockmaker import BGSMaker\\n\\n%time demo_mockmaker(BGSMaker, seed=seed)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create Linear Model\\n\",\"targets\":\"# Create a linear regression\\nols = linear_model.LinearRegression()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Falcon-9\\/Falcon-9 frames.ipynb\\\".\\nThe first task is:\\nThis notebook shows an analysis of the Falcon-9 upper stage S-band telemetry frames. It is based on r00t.cz's analysis.\\nThe frames are CCSDS Reed-Solomon frames with an interleaving depth of 5, a (255,239) code, and an (uncoded) frame size of 1195 bytes.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nx = np.fromfile('falcon9_frames_20210324_084608.u8', dtype = 'uint8')\\nx = x.reshape((-1, 1195))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Python\\/4 Automatic Theorem Proving\\/Knuth-Bendix-Algorithm-KBO.ipynb\\\".\\nThe first task is:\\nWe define the class OrderException to be able to deal with equations that can't be ordered into a rewrite rule.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nclass OrderException(Exception):\\n pass\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# agg\\nx = sqlContext.createDataFrame([(\\\"Alice\\\",\\\"Bob\\\",0.1),(\\\"Bob\\\",\\\"Carol\\\",0.2),(\\\"Carol\\\",\\\"Dave\\\",0.3)], ['from','to','amt'])\\ny = x.agg({\\\"amt\\\":\\\"avg\\\"})\\nx.show()\\ny.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n\\n\\n<\\/a>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# plot strings!\\nn_qubits = len(graph.nodes())\\ndef plot(inst, probs):\\n probs = probs.real\\n states = inst.states\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.set_xlabel(\\\"state\\\",fontsize=20)\\n ax.set_ylabel(\\\"Probability\\\",fontsize=20)\\n ax.set_xlim([0, 2**n_qubits])\\n rec = ax.bar(range(2**n_qubits), probs[:,0],)\\n num_states = [0, \\n int(\\\"\\\".join(str(x) for x in [0,1] * (n_qubits\\/\\/2)), 2),\\n int(\\\"\\\".join(str(x) for x in [1,0] * (n_qubits\\/\\/2)), 2),\\n 2**n_qubits - 1]\\n ax.set_xticks(num_states)\\n ax.set_xticklabels(map(lambda x: inst.states[x], num_states), rotation=90)\\n plt.grid(True)\\n plt.tight_layout()\\n plt.show()\\n\\nt = np.hstack((betas, gammas))\\nprobs = ring_cut_inst.probabilities(t)\\nplot(ring_cut_inst, probs)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe can see that the first 2 most frequently sampled strings are the alternating solutions to the ring graph (well damn, they are). Since we have to access the wave function, we can go one step further and view the probability distribution over the bit strings produced by our $p = 1$ circuit.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Plot photon current density<\\/h3>\\nPhoton current density is then calculated at $z=d$ and plotted below as a function of time.<\\/font><\\/p>\\n\",\"targets\":\"particlecurrentarray = []\\ntarray = []\\nfor t in linspace(10**-15,50*10**-12,1000):\\n tarray.append(t*10**12)\\n particlecurrentarray.append(particlecurrent(t))\\n\\n#Update the matplotlib configuration parameters\\nmpl.rcParams.update({'font.size': 18, 'font.family': 'serif'})\\n\\n#Adjust figure size\\nplt.subplots(figsize=(12,6))\\n\\nplt.plot(tarray,particlecurrentarray,linewidth=2)\\nplt.xlim(np.min(tarray),np.max(tarray))\\nplt.ylim(0)\\nplt.xlabel('time (ps)')\\nplt.ylabel('Photon Current at $z=d$ $(s^{-1} \\\\cdot m^{-2})$')\\n#plt.semilogy()\\nplt.legend(loc=4)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"02_introduction\\/intro_to_python.ipynb\\\".\\nThe first task is:\\nUnicode string\\nLike strings, but with more characters!\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmy_unicode = u'Hellö World!'\\nmy_unicode\\n\\nprint(my_unicode)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.14\\/_downloads\\/plot_object_raw.ipynb\\\".\\nThe first task is:\\nThe :class:Raw <mne.io.Raw> data structure: continuous data\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom __future__ import print_function\\n\\nimport mne\\nimport os.path as op\\nfrom matplotlib import pyplot as plt\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Combine generation into one large dataframe\\n\",\"targets\":\"if __name__ == '__main__':\\n exception_list = []\\n facility_gen = pd.concat(Parallel(n_jobs=-1)(delayed(facility_line_to_df)(json.loads(row)) for row in gen_rows))\\n facility_gen.reset_index(drop=True, inplace=True)\\n facility_gen.rename({'value':'generation (MWh)'}, axis=1, inplace=True)\\n\\nfacility_gen.loc[:,'lat'] = facility_gen.loc[:,'lat'].astype(float)\\nfacility_gen.loc[:,'lon'] = facility_gen.loc[:,'lon'].astype(float)\\nfacility_gen.loc[:, 'plant id'] = facility_gen.loc[:, 'plant id'].astype(int)\\n\\n#drop\\nfacility_gen.tail()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Exercises-1.ipynb\\\".\\nThe first task is:\\n96\\nHow many people have played a role called \\\"The Dude\\\"?\\nCan you write Python code for it?\\n\",\"targets\":\"\\nc = cast\\nc = c[c.character == \\\"The Dude\\\"]\\nlen(c)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"All input data is stored in pandas dataframes under, self.Data.Interances and self.Data.Foliations:\\n\",\"targets\":\"sandstone.Data.Foliations.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapman\\/Ch1-Problem_1-19.ipynb\\\".\\nThe first task is:\\nAnswer the following questions about this power system.\\n(a)\\n\\nAssume that the switch shown in the figure is initially open, and calculate the current I , the power factor, and the real, reactive, and apparent power being supplied by the source.\\n\\n(b)\\n\\nHow much real, reactive, and apparent power is being consumed by each load with the switch open?\\n\\n(c)\\n\\nAssume that the switch shown in the figure is now closed, and calculate the current I , the power factor, and the real, reactive, and apparent power being supplied by the source.\\n\\n(d)\\n\\nHow much real, reactive, and apparent power is being consumed by each load with the switch closed?\\n\\n(e)\\n\\nWhat happened to the current flowing from the source when the switch closed? Why?\\n\\nSOLUTION\\n(a)\\nWith the switch open, only loads 1 and 2 are connected to the source. The current $\\\\vec{I}_1$ in Load 1 and the current $\\\\vec{I}_2$ in Load 2 are:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nI1 = V\\/Z1\\nI2 = V\\/Z2\\nI1_angle = arctan(I1.imag\\/I1.real)\\nI2_angle = arctan(I2.imag\\/I2.real)\\nprint('''I1 = {:.1f} A ∠{:.1f}°\\nI2 = {:.1f} A ∠{:.1f}°'''.format(\\n abs(I1), I1_angle\\/pi*180,\\n abs(I2), I2_angle\\/pi*180))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"LSTM.ipynb\\\".\\nThe first task is:\\nTraining is good, but having visual insight is even better:\\nOkay, let's plot this simply in the notebook for now.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# (Inline plots: )\\n%matplotlib inline\\n\\nfont = {\\n 'family' : 'Bitstream Vera Sans',\\n 'weight' : 'bold',\\n 'size' : 18\\n}\\nmatplotlib.rc('font', **font)\\n\\nwidth = 12\\nheight = 12\\nplt.figure(figsize=(width, height))\\n\\nindep_train_axis = np.array(range(batch_size, (len(train_losses)+1)*batch_size, batch_size))\\nplt.plot(indep_train_axis, np.array(train_losses), \\\"b--\\\", label=\\\"Train losses\\\")\\nplt.plot(indep_train_axis, np.array(train_accuracies), \\\"g--\\\", label=\\\"Train accuracies\\\")\\n\\nindep_test_axis = np.append(\\n np.array(range(batch_size, len(test_losses)*display_iter, display_iter)[:-1]),\\n [training_iters]\\n)\\nplt.plot(indep_test_axis, np.array(test_losses), \\\"b-\\\", label=\\\"Test losses\\\")\\nplt.plot(indep_test_axis, np.array(test_accuracies), \\\"g-\\\", label=\\\"Test accuracies\\\")\\n\\nplt.title(\\\"Training session's progress over iterations\\\")\\nplt.legend(loc='upper right', shadow=True)\\nplt.ylabel('Training Progress (Loss or Accuracy values)')\\nplt.xlabel('Training iteration')\\n\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\n Solution<\\/summary>\\n We can fetch the html at that url with the following code:\\n\\n ```\\n # import the library we will use\\n import requests\\n\\n # specify the url where the data we want to fetch lives\\n url = 'http:\\/\\/www.gutenberg.org\\/files\\/1342\\/1342-h\\/1342-h.htm'\\n\\n # get the data at the requested url\\n response = requests.get(url)\\n\\n # get the HTML from the response\\n html = response.text\\n ```\\n<\\/details>\\n\\nParsing HTML data with BeautifulSoup\\nAfter fetching some HTML data, the next thing we'll want to do is to \\\"parse\\\" that HTML to extract the subset of the data that's of interest. \\nIn what follows, we'll use the BeautifulSoup library to parse HTML. To get started with BeautifulSoup, let's install it with the following command:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n!pip install beautifulsoup4\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"But what is so special about solutions of minimum length? For machine\\nlearning, driving the objective function to zero is symptomatic of overfitting\\nthe data. Usually, at the zero bound, the machine learning method has\\nessentially memorized the training data, which is bad for generalization. Thus,\\nwe can effectively stall this problem by defining a region for the solution\\nthat is away from the zero-bound.\\n$$\\n\\\\begin{aligned}\\n& \\\\underset{\\\\boldsymbol{\\\\beta}}{\\\\text{minimize}}\\n& & \\\\Vert y - \\\\mathbf{X}\\\\boldsymbol{\\\\beta}\\\\Vert_2^2 \\\\\\n& \\\\text{subject to:}\\n& & \\\\Vert\\\\boldsymbol{\\\\beta}\\\\Vert_2 < c\\n\\\\end{aligned}\\n$$\\nwhere $c$ is the tuning parameter. Using the same process as before,\\nwe can re-write this as the following,\\n$$\\n\\\\min_{\\\\boldsymbol{\\\\beta}\\\\in\\\\mathbb{R}^p}\\\\Vert\\ny-\\\\mathbf{X}\\\\boldsymbol{\\\\beta}\\\\Vert_2^2 +\\\\alpha\\\\Vert\\\\boldsymbol{\\\\beta}\\\\Vert_2^2\\n$$\\nwhere $\\\\alpha$ is the tuning parameter. These are the penalized or\\nLagrange forms of these problems derived from the constrained versions. The\\nobjective function is penalized by the $\\\\Vert\\\\boldsymbol{\\\\beta}\\\\Vert_2$ term.\\nFor $L_2$ penalization, this is called ridge regression. This is\\nimplemented in Scikit-learn as Ridge. The following code sets this up for\\nour example,\\n\",\"targets\":\"from sklearn.linear_model import Ridge\\nclf = Ridge(alpha=100.0,fit_intercept=False)\\nclf.fit(np.array(X).astype(float),np.array(y).astype(float))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Read in the flight and radar data<\\/b>\\n\",\"targets\":\"fl1 = awot.io.read_netcdf(fname=FltLevf[1:-1], platform='p-3')\\nr1 = awot.io.read_windsyn_tdr_netcdf(fname=P3Radf[1:-1], field_mapping=None)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2. TF-slim(tf.contrib.slim)\\n\\nContrib 중 하나의 library로, 상위 수준의 개념(argument scoping, layer, variable)으로 모델을 짧고 쉽게 정의할 수 있게 만듦\\n많이 사용되는 regularizer를 사용하여 모델을 단순하게 함. VGG, AlexNet과 같이 많이 쓰이는 모델을 개발 해놓음\\n\\nwithout TF-Slim\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ninput = ...\\nwith tf.name_scope('conv1_1') as scope:\\n kernel = tf.Variable(tf.truncated_normal([3, 3, 64, 128], dtype=tf.float32,\\n stddev=1e-1), name='weights')\\n conv = tf.nn.conv2d(input, kernel, [1, 1, 1, 1], padding='SAME')\\n biases = tf.Variable(tf.constant(0.0, shape=[128], dtype=tf.float32),\\n trainable=True, name='biases')\\n bias = tf.nn.bias_add(conv, biases)\\n conv1 = tf.nn.relu(bias, name=scope)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#If current prices are higher than 50 or 200 days moving average, that means prices are going up\\n\\n#200 days moving average\\nth_moving_avg = google.get_200day_moving_avg()\\n\\n#50 days moving average\\nfifty_moving_avg = google.get_50day_moving_avg()\\n\\nprint \\\"200 days moving average: $\\\", th_moving_avg\\nprint \\\"50 days moving average: $\\\", fifty_moving_avg\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nMoving averages. Get a peek of what prices have been like in the past.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1. Exploratory Data Analysis <\\/a>\\nThe data we have to work with looks at households in Bangladesh, some of which were affected by high levels of arsenic in their water. Would affected households want to switch to a neighbour's well?\\nWe'll split the data into a train and test set, and then we'll train six different models to try to predict whether households would switch wells. Then, we'll see how we can stack them when predicting on the test set!\\nBut first, let's load it in and visualise it! Each row represents a household, and the features we have available to us are:\\n\\nswitch: whether a household switched to another well;\\narsenic: level of arsenic in drinking water;\\neduc: level of education of \\\"head of household\\\";\\ndist100: distance to nearest safe-drinking well;\\nassoc: whether the household participates in any community activities.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nwells = pd.read_csv(\\n \\\"http:\\/\\/stat.columbia.edu\\/~gelman\\/arm\\/examples\\/arsenic\\/wells.dat\\\", sep=\\\" \\\"\\n)\\n\\nwells.head()\\n\\nfig, ax = plt.subplots(2, 2, figsize=(12, 6))\\nfig.suptitle(\\\"Target variable plotted against various predictors\\\")\\nsns.scatterplot(data=wells, x=\\\"arsenic\\\", y=\\\"switch\\\", ax=ax[0][0])\\nsns.scatterplot(data=wells, x=\\\"dist\\\", y=\\\"switch\\\", ax=ax[0][1])\\nsns.barplot(\\n data=wells.groupby(\\\"assoc\\\")[\\\"switch\\\"].mean().reset_index(),\\n x=\\\"assoc\\\",\\n y=\\\"switch\\\",\\n ax=ax[1][0],\\n)\\nax[1][0].set_ylabel(\\\"Proportion switch\\\")\\nsns.barplot(\\n data=wells.groupby(\\\"educ\\\")[\\\"switch\\\"].mean().reset_index(),\\n x=\\\"educ\\\",\\n y=\\\"switch\\\",\\n ax=ax[1][1],\\n)\\nax[1][1].set_ylabel(\\\"Proportion switch\\\");\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Figure\\nplt.figure(figsize=(10,8))\\n\\n# Scatter plot of the data points\\nplt.scatter(X[Y==0,0], X[Y==0,3], color='red')\\nplt.scatter(X[Y==1,0], X[Y==1,3], color='blue')\\nplt.scatter(X[Y==2,0], X[Y==2,3], color='green')\\n\\n# Labels\\nplt.title('Fisher\\\\'s iris datset')\\nplt.xlabel('Sepal length')\\nplt.ylabel('Petal width')\\n\\n# Show\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nScatter plot of data\\nFirst, lets produce a scatter plot of sepal length and petal width, with the colour of the points indicating ground truth class:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# 입력 크기는 영화 리뷰 데이터셋에 적용된 어휘 사전의 크기입니다(10,000개의 단어)\\nvocab_size = 10000\\n\\nmodel = keras.Sequential()\\nmodel.add(keras.layers.Embedding(vocab_size, 16, input_shape=(None,)))\\nmodel.add(keras.layers.GlobalAveragePooling1D())\\nmodel.add(keras.layers.Dense(16, activation=tf.nn.relu))\\nmodel.add(keras.layers.Dense(1, activation=tf.nn.sigmoid))\\n\\nmodel.summary()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n모델 구성\\n신경망은 층(layer)을 쌓아서 만듭니다. 이 구조에서는 두 가지를 결정해야 합니다:\\n\\n모델에서 얼마나 많은 층을 사용할 것인가?\\n각 층에서 얼마나 많은 은닉 유닛(hidden unit)을 사용할 것인가?\\n\\n이 예제의 입력 데이터는 단어 인덱스의 배열입니다. 예측할 레이블은 0 또는 1입니다. 이 문제에 맞는 모델을 구성해 보죠:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Code\\/notebooks\\/bootcamp_graphics_s17_UG.ipynb\\\".\\nThe first task is:\\nComment. All of these statements must be in the same cell for this to work. \\nComment. This is overkill -- it looks horrible -- but it makes the point that we control everything in the plot. We recommend you do very little of this until you're more comfortable with the basics. \\n\\nApproach 3: Create figure objects and apply methods\\nThis approach is probably the most mysterious, but it's the best. \\nThe idea is to use the matplotlib.pyplot function subplots(), which creates two objects:\\n* fig : figure object -- blank canvas for creating a figure\\n* ax : axis object -- everything in the figure: axes, labels, legend\\napply methods on these objects to set the various elements of the graph. \\nCreate objects. We'll see this line over and over:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfig, ax = plt.subplots() # create fig and ax objects\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Note<\\/h4>Creating an :class:`mne.Epochs` object with metadata is done by passing\\n a :class:`pandas.DataFrame` to the ``metadata`` kwarg as follows:<\\/p><\\/div>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndata = epochs.get_data()\\nmetadata = epochs.metadata.copy()\\nepochs_new = mne.EpochsArray(data, epochs.info, metadata=metadata)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Baseline model\\n\",\"targets\":\"rf = RandomForestClassifier(n_estimators=100, n_jobs=-1)\\nrf.fit(X_train, y_train)\\n\\ny_pred = rf.predict_proba(X_test)\\n\\nauc = roc_auc_score(y_true=y_test, y_score=y_pred[:, 1])\\n\\nauc\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\n EXERCISE<\\/b>: Join the `readings` and `visited` tables.\\n<\\/div>\\n\\n\\n EXERCISE<\\/b>: Pivot the table such that we have sites in rows and different quantities in columns.\\n<\\/div>\\n\\nHierarchical index\\nHierarchical index of pandas is a way of introducing another dimension to a (two-dimensional) data frame. This is implemented by having multiple levels of the index. Let's look at an example.\\n\",\"targets\":\"multi = df.set_index(['subject', 'treatment'])\\nmulti\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Currently, jointplot wraps JointGrid with the following options for kind:\\n - scatter\\n - reg\\n - resid \\n - kde \\n - hex \\nScatter is the default parameters\\n\",\"targets\":\"p = sns.jointplot(data=df,x='x', y='y',kind='scatter')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"As many instances of the bird class can be generated as desired, though it may quickly become boring. One of the important benefits of using object-oriented classes is code re-use. For example, we may want more specific kinds of birds, with unique functionality:\\n\",\"targets\":\"class Duck(Bird):\\n # Duck is a subclass of bird\\n\\n name = 'duck'\\n \\n def swim(self):\\n # Ducks can swim\\n\\n print('Swimming!')\\n\\n def quack(self,n):\\n # Ducks can quack\\n \\n print('Quack! ' * n)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Compute an acceleration error. Here we just use the magnitude of the vector difference between the estimated acceleration and the true acceleration.\\n\",\"targets\":\"acc_err_dsf = np.array([np.linalg.norm(acc_true1 - acc_dsf1) for acc_true1, acc_dsf1 in zip(accdyn_true.T, accdyn_dsf.T)])\\nacc_err_mad = np.array([np.linalg.norm(acc_true1 - acc_mad1) for acc_true1, acc_mad1 in zip(accdyn_true.T, accdyn_mad.T)])\\n\\nfig, ax = plt.subplots(1, 2, gridspec_kw = {'width_ratios':[3, 1]}, sharey=True)\\n\\nax[0].plot(t, acc_err_dsf, label='dsf')\\nax[0].plot(t, acc_err_mad, label='mad')\\nax[0].legend()\\nax[0].set_xlabel('Time (sec)')\\nax[0].set_ylabel('Error (m\\/s^2)')\\n\\nax[1].bar([1, 2], [np.mean(acc_err_dsf), np.mean(acc_err_mad)])\\nax[1].set_xticks([1, 2])\\nax[1].set_xticklabels(['dsf', 'mad'])\\n\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Lecture-version_control.ipynb\\\".\\nThe first task is:\\nAt this point, we can push again the update to the remote repository:\\nbash\\ngit push origin master\\nDelete a remote repository\\nBy far the easiest way is to log in your gitHub account:\\n\\nClick to your repository: https:\\/\\/github.com\\/yourUsername\\/yourRepository,\\n for example:\\n\\nbash\\n https:\\/\\/github.com\\/darioflute\\/planets\\n\\nThen in the main toolbar of github click on Settings, or directly type the URL:\\n\\nbash\\n https:\\/\\/github.com\\/darioflute\\/planets\\/settings\\n\\nScroll down and you will find Delete this repository button.\\n\\nHosted repositories\\nGithub.com is a git repository hosting site that is very popular with both open source projects (for which it is free) and private repositories (for which a subscription might be needed).\\nWith a hosted repository it easy to collaborate with colleagues on the same code base, and you get a graphical user interface where you can browse the code and look at commit logs, track issues etc. \\nSome good hosted repositories are\\n\\nGithub : http:\\/\\/www.github.com\\nBitbucket: http:\\/\\/www.bitbucket.org\\n\\nGraphical user interfaces\\nThere are also a number of graphical users interfaces for GIT. The available options vary a little bit from platform to platform:\\nhttp:\\/\\/git-scm.com\\/downloads\\/guis\\ngitk is a popular browser for GIT\\ngit-gui is a tool to use GIT in a graphical way\\nThey can be easily installed in linux with apt-get or synaptic.\\n\\nFurther reading\\n\\nhttp:\\/\\/git-scm.com\\/book\\nhttp:\\/\\/www.vogella.com\\/articles\\/Git\\/article.html\\nhttp:\\/\\/cheat.errtheblog.com\\/s\\/git\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%load_ext version_information\\n%version_information version_information\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Calibrated Recommendations\\nWhen a user has watched, say, 70% romance movies and 30% action movies in the past, then it is reasonable to expect the personalized list of recommended movies to be comprised of 70% romance and 30% action movies as well since we would like to cover the user's diverse set of interests. A recommendation that actually reflect most if not all of the user's interest is considered a Calibrated Recommendation. But the question is, does our recommendation exhibit this trait?\\nRecommendation algorithm provides personalized user experience past on the user's past historical interaction with the product\\/system\\/website. However, when serving the recommendation such as recommendation top 10 movies that we think the user might be interested in, a recommendation engine that is solely measured based on ranking metrics can easily generate recommendations that focus on the main area of interests, resulting the user's other area of interest to be under-represented, or worse, absent in the final recommendation.\\nTo hit the notion home, using the example above, given a user that has watched 70% romance movies and 30% action movies, if we were to solely measure the metric based on precision, we can say we can achieve the best performance by predicting the majority genre, i.e. we will recommend 100% romance movies and we can expect the user to interact with those recommendations 70% of the time. On other other hand, if we were to recommend 70% romance movies and 30% action movies, then we would expect our recommendation to only be correct 0.7 * 0.7 + 0.3 * 0.3 = 58% of the time.\\nThroughout the rest of this notebook, we will take a look at if the phenomenon of crowding out user's sub-interest occurs with our recommendation, develop a quantitative metric to measure how severe this issue is and implement a post-preprocessing logic that is agnostic of the underlying recommendation algorithm we decided to use to ensure the recommendation becomes more calibrated.\\nPreparation\\nWe'll be using the publicly available...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndata_dir = 'movielens-20m-dataset'\\n\\n# we are working with movie data, but we'll name\\n# the movie as item to make it more generic to\\n# all use-cases\\nuser_col = 'userId'\\nitem_col = 'movieId'\\nvalue_col = 'rating'\\ntime_col = 'timestamp'\\n\\nrating_path = os.path.join(data_dir, 'rating.csv')\\ndf_raw = pd.read_csv(rating_path)\\nprint('dimension: ', df_raw.shape)\\ndf_raw.head()\\n\\ntitle_col = 'title'\\ngenre_col = 'genres'\\n\\nitem_info_path = os.path.join(data_dir, 'movie.csv')\\ndf_item = pd.read_csv(item_info_path)\\ndf_item = df_item[df_item[genre_col] != '(no genres listed)']\\nprint('dimension: ', df_item.shape)\\ndf_item.head()\\n\\nclass Item:\\n \\\"\\\"\\\"\\n Data holder for our item.\\n \\n Parameters\\n ----------\\n id : int\\n \\n title : str\\n\\n genre : dict[str, float]\\n The item\\/movie's genre distribution, where the key\\n represents the genre and value corresponds to the\\n ratio of that genre.\\n\\n score : float\\n Score for the item, potentially generated by some\\n recommendation algorithm.\\n \\\"\\\"\\\"\\n def __init__(self, _id, title, genres, score=None):\\n self.id = _id\\n self.title = title\\n self.score = score\\n self.genres = genres\\n\\n def __repr__(self):\\n return self.title\\n\\n\\ndef create_item_mapping(df_item, item_col, title_col, genre_col):\\n \\\"\\\"\\\"Create a dictionary of item id to Item lookup.\\\"\\\"\\\"\\n item_mapping = {}\\n for row in df_item.itertuples():\\n item_id = getattr(row, item_col)\\n item_title = getattr(row, title_col)\\n item_genre = getattr(row, genre_col)\\n\\n splitted = item_genre.split('|')\\n genre_ratio = 1. \\/ len(splitted)\\n item_genre = {genre: genre_ratio for genre in splitted}\\n\\n item = Item(item_id, item_title, item_genre)\\n item_mapping[item_id] = item\\n\\n return item_mapping\\n \\n\\nitem_mapping = create_item_mapping(df_item, item_col, title_col, genre_col)\\nitem_mapping[1]\\n\\n# convert to implicit feedback data and filter out\\n# movies that doesn't have any genre\\ndf_rating = df_raw[df_raw[value_col] >=...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create a new dataframe for plotting: rows are powers, columns are periods, value is percent of hits\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nplotDF = pd.DataFrame(0,index=powers,columns=freqs)\\nnonZeroFreqs=[]\\nfor power in powers:\\n for freq in freqs:\\n value = DF[(DF['frequency']==freq) & (DF['power']== power)]['percent'].values\\n try:\\n plotDF.loc[power,freq] = value[0]\\n if value[0] != 0:\\n # Keep track of the frequencies that have hits, for axes limits\\n nonZeroFreqs.append(freq)\\n except:\\n continue\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapter-5-Logistic Regression.ipynb\\\".\\nThe first task is:\\nStep 5: Define the Cost of Getting it Wrong\\nThe cost of classfying things wrong is defined as\\n$$J(\\\\theta) = \\\\frac{1}{m} \\\\sum_{i=1}^{m} [-y^{(i)} log(g_{\\\\theta}(x^{(i)})) - (1-y^{(i)}) log(1-g_{\\\\theta}(x^{(i)}))]$$\\nAs always, the cost of getting it wrong is defined over the entire dataset. There are $m$ rows of data and each $x^{(i)}$ consists of the two scores in a row of the dataset.\\nLet's visualize this cost function. [[VISUALIZE COST FUNCTION]]\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Visualize the cost function when y = 1 and y = 0\\nx_vals = np.linspace(0,1,100)\\ny_1_vals = -np.log(x_vals)\\ny_0_vals = -np.log(1 - x_vals)\\n\\nfig, ax = plt.subplots(figsize=(8,5))\\nax.plot(x_vals, y_1_vals, color='blue', linestyle='solid', label='y = 1')\\nax.plot(x_vals, y_0_vals, color='yellow', linestyle='solid', label='y = 0')\\nplt.legend(loc='upper center')\\nplt.xlabel(r'$g_{\\\\theta}(x)$', fontsize=15)\\nplt.ylabel(r'$J(\\\\theta)$', fontsize=15)\\nax.plot\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Day_2\\/solutions\\/17-Pandas-Intro-Solution.ipynb\\\".\\nThe first task is:\\nSetting missing values\\nAs you may notice, we have negative values of ozone concentration, which does not make sense. So, let us replace those negative values with NaN:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nair_quality[air_quality.O3.values < 0]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapman\\/Ch8-Problem_8-01to09.ipynb\\\".\\nThe first task is:\\nr\\/min. The actual internal generated voltage $E_A$ at these conditions is:\\n$$E_A = V_T - I_A R_A$$\\nCan you write Python code for it?\\n\",\"targets\":\"\\nEao_4 = 185.0 # [r\\/min]\\nEa_4 = Vt - Ia*Ra\\nEa_4 # [V]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Columns of the datetime type have an accessor to easily extract properties of the data type. This will return a Series, with the same row index as the DataFrame. For example:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsegments.st_time.dt.month.head()\\n\\nsegments.st_time.dt.hour.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Importando um módulo em Python\\nimport math\\n\\n# Verificando todos os métodos disponíveis no módulo\\ndir(math)\\n\\n# Usando um dos métodos do módulo math\\nmath.sqrt(25)\\n\\n# Importando apenas um dos métodos do módulo math\\nfrom math import sqrt\\n\\n# Usando o método\\nsqrt(9)\\n\\n# Imprimindo todos os métodos do módulo math\\nprint(dir(math))\\n\\n# Help do método sqrt do módulo math\\nhelp(sqrt)\\n\\nimport random\\n\\nrandom.choice(['Maça', 'Banana', 'Laranja'])\\n\\nrandom.sample(range(100), 10)\\n\\nimport statistics\\n\\ndados = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]\\n\\nstatistics.mean(dados)\\n\\nstatistics.median(dados)\\n\\nimport os\\n\\nos.getcwd()\\n\\nprint(dir(os))\\n\\nimport sys\\n\\nsys.stdout.write('Teste')\\n\\nsys.version\\n\\nprint(dir(sys))\\n\\n# Importando o módulo request do pacote urllib, usado para trazer url's \\n# para dentro do nosso ambiente Python\\nimport urllib.request\\n\\n# Variável resposta armazena o objeto de conexão à url passada como \\n# parâmetro\\nresposta = urllib.request.urlopen('http:\\/\\/python.org')\\n\\n# Objeto resposta\\nprint(resposta)\\n\\n# Chamando o método read() do objeto resposta e armazenando o código \\n# html na variável html\\nhtml = resposta.read()\\n\\n# Imprimindo html\\nprint(html)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nMódulos e Pacotes\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"<\\/a>\\nMarch4Trump Tweets\\n\",\"targets\":\"import pickle\\n\\ndata = pickle.load(open(\\\"tweets.pkl\\\", \\\"rb\\\"))\\n\\nprint(len(data))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# female = 0, Male = 1\\n# Add a new column to the data file labeled \\\"gender\\\" that maps \\\"Sex\\\" into integer values.\\ntrain_df['Gender'] = train_df['Sex'].map( {'female': 0, 'male': 1} ).astype(int)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nConvert strings to integer classifiers.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Adding well screen resistance does not improve the performance obviously. While the AIC value increases. Thus, res should be removed from the model.\\nTry multilayer conceptual model:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n#Determine elevations of each layer.\\n#Thickness of each layer is set to be 0.5 m.\\nz = np.arange(0, b, -0.5)\\nzlay = np.append(z, b)\\nnlay = len(zlay) - 1\\nSaq_2 = 1e-4 * np.ones(nlay)\\nn = np.arange(0, 13,1)\\n\\nml_2 = Model3D(kaq=10, z=zlay, Saq=Saq_2, kzoverkh=1, tmin=1e-5, tmax=0.01, \\\\\\n phreatictop=True)\\nw_2 = Well(ml_2, xw=0, yw=0, rw=rw1, tsandQ=[(0, -Q)], layers=n, rc=rc1, \\\\\\n wbstype='slug')\\nml_2.solve()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Automatically detect significant periods\\n\",\"targets\":\"# Open the data and get a subset\\nhdulist = fits.open('\\/grp\\/hst\\/hstlc\\/hst13902\\/outputs\\/composite\\/V-KL-UMA_FUV_G160M_1600_curve.fits', mode='readonly')\\nsubset = np.where(56853 < hdulist[1].data['mjd'])\\nall_counts = hdulist[1].data['net'] # use flux for longer timescales, otherwise use net\\nall_times = hdulist[1].data['mjd']\\ncounts, times = [], []\\nfor count, time in zip(all_counts, all_times):\\n if 56853.930 < time < 56853.955:\\n counts.append(count)\\n times.append(time)\\n\\nshort_periods = np.linspace(short_freq, med_freq, len(times))\\nmed_periods = np.linspace(med_freq, long_freq, len(times))\\nlong_periods = np.linspace(long_freq, max_freq, len(times))\\n\\nshort_ang_freqs = 2 * np.pi \\/ short_periods\\nmed_ang_freqs = 2 * np.pi \\/ med_periods\\nlong_ang_freqs = 2 * np.pi \\/ long_periods\\n\\nshort_power = lombscargle(np.asarray(times), np.asarray(counts) - np.asarray(counts).mean(), short_ang_freqs)\\nmed_power = lombscargle(np.asarray(times), np.asarray(counts) - np.asarray(counts).mean(), med_ang_freqs)\\nlong_power = lombscargle(np.asarray(times), np.asarray(counts) - np.asarray(counts).mean(), long_ang_freqs)\\nshort_power *= 2 \\/ (len(times) * np.asarray(counts).std() ** 2)\\nmed_power *= 2 \\/ (len(times) * np.asarray(counts).std() ** 2)\\nlong_power *= 2 \\/ (len(times) * np.asarray(counts).std() ** 2)\\n\\nshort_mean = np.mean(short_power)\\nmed_mean = np.mean(med_power)\\nlong_mean = np.mean(long_power)\\n\\nshort_std = np.std(short_power)\\nmed_std = np.std(med_power)\\nlong_std = np.std(long_power)\\n\\nshort_three_sigma = 3 * short_std\\nmed_three_sigma = 3 * med_std\\nlong_three_sigma = 3 * long_std\\n\\nshort_power_three_sigma = np.where(short_power > short_three_sigma)\\nmed_power_three_sigma = np.where(med_power > med_three_sigma)\\nlong_power_three_sigma = np.where(long_power > long_three_sigma)\\nshort_period_three_sigma = np.where(short_power > short_three_sigma)\\nmed_period_three_sigma = np.where(med_power > med_three_sigma)\\nlong_period_three_sigma = np.where(long_power > long_three_sigma)\\n\\nshort_starting_index =...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"00_Intro_Python_Jupyter_notebooks\\/2_Jupyter_strings_and_lists.ipynb\\\".\\nThe first task is:\\nWhat if we want to add a space that separates hello from world? We directly add the string ' ' in the middle of the two variables. A space is a character!\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmy_string = str_1 + ' ' + str_2\\nprint(my_string)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"First calling and training the algorithm.\\nA specificity here is the presence of the 'shape_1X' keyword to specify the shape of a single sample.\\nI have added it as pictures fed to the machinery might not be square. \\nObviously it is not very relevant for the iris data set but still, it has to be defined.<\\/p>\\n**New in version 0.1.3** : possibility to directly use an int as shape_1X for sequence data.<\\/p>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ngcf = gcForest(shape_1X=4, window=2, tolerance=0.0)\\ngcf.fit(X_tr, y_tr)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# format payload\\nhttp_body = httpbody_pb2.HttpBody(\\n data=open(payload_file).read().encode(\\\"utf-8\\\"),\\n content_type=\\\"application\\/json\\\",\\n)\\n\\n# Initialize request argument(s)\\nrequest = gapic.RawPredictRequest(endpoint=endpoint_name, http_body=http_body)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFormat the http request\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"AlignInfo\\n\",\"targets\":\"from Bio import AlignIO\\nfrom Bio.Align.AlignInfo import SummaryInfo\\nfrom Bio.Alphabet import ProteinAlphabet\\n\\nalign = AlignIO.read('samples\\/cas9align.fasta', 'fasta', alphabet=ProteinAlphabet())\\nsummary = SummaryInfo(align)\\nprint(summary.information_content())\\n\\nsummary.dumb_consensus(consensus_alpha=ProteinAlphabet())\\n\\nsummary.gap_consensus(consensus_alpha=ProteinAlphabet())\\n\\nprint(summary.alignment)\\n\\nprint(summary.pos_specific_score_matrix())\\n\\nfrom Bio.Align.Applications import ClustalwCommandline\\nclustalw_exe = 'clustalw2'\\nccli = ClustalwCommandline(clustalw_exe, infile=\\\"samples\\/input4align.fasta\\\", outfile='..\\/..\\/aoutput.aln')\\nprint(ccli)\\n\\n\\n clustalw_exe = 'clustalw2'\\n\\nclustalw_exe='c:\\\\\\\\windows\\\\\\\\program file\\\\\\\\clustal\\\\\\\\clustalw.exe'\\n\\nfrom Bio.Align.Applications import ClustalwCommandline\\nclustalw_exe = 'clustalw2'\\nccli = ClustalwCommandline(clustalw_exe,\\ninfile=\\\"samples\\/input4align.fasta\\\", outfile='..\\/..\\/aoutput.aln')\\nccli()\\n\\nfrom Bio import AlignIO\\nseqs = AlignIO.read('samples\\/aoutput.aln', 'clustal')\\nseqs[0]\\n\\nseqs[1]\\n\\nseqs[2]\\n\\nfrom Bio.Align.Applications import ClustalwCommandline\\nclustalw_exe = 'clustalw2'\\nccli = ClustalwCommandline(clustalw_exe,\\ninfile=\\\"input4align.fasta\\\", outfile='..\\/..\\/aoutput.aln',\\npwgapopen=5)\\nprint(ccli)\\n\\nfrom Bio.Align.Applications import ClustalwCommandline\\nccli = ClustalwCommandline()\\nhelp(ccli)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Oracle_Jupyter\\/Oracle_histograms.ipynb\\\".\\nThe first task is:\\nFetch the histogram data into a pandas dataframe\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport pandas as pd\\n\\n# query Oracle using ora_conn and put the result into a pandas Dataframe\\nwith oracledb.connect(user=db_user, password=db_pass, dsn=db_connect_string) as ora_conn:\\n hist_pandasDF = pd.read_sql(query, con=ora_conn) \\n\\n# Decription\\n#\\n# BUCKET: the bucket number, range from 1 to bins (included)\\n# VALUE: midpoint value of the given bucket\\n# COUNT: number of values in the bucket \\n \\nhist_pandasDF\\n\\n# Optionally normalize the event count into a frequency\\n# dividing by the total number of events\\n \\nhist_pandasDF[\\\"FREQUENCY\\\"] = hist_pandasDF[\\\"COUNT\\\"] \\/ sum(hist_pandasDF[\\\"COUNT\\\"]) \\n \\nhist_pandasDF\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\" \\n \\n<\\/a>\\nPlotting the sample data\\nTo get an intuitive idea of how our data looks like, let us visualize it in a simple scatter plot.\\n\",\"targets\":\"%pylab inline\\n\\nimport numpy as np\\nfrom matplotlib import pyplot as plt\\n\\nf, ax = plt.subplots(figsize=(7, 7))\\nax.scatter(x1_samples[:,0], x1_samples[:,1], marker='o', color='green', s=40, alpha=0.5, label='$\\\\omega_1$')\\nax.scatter(x2_samples[:,0], x2_samples[:,1], marker='s', color='blue', s=40, alpha=0.5, label='$\\\\omega_2$')\\nax.scatter(x3_samples[:,0], x3_samples[:,1], marker='^', color='red', s=40, alpha=0.5, label='$\\\\omega_2$')\\nplt.legend(loc='upper right') \\nplt.title('Training Dataset', size=20)\\nplt.ylabel('$x_2$', size=20)\\nplt.xlabel('$x_1$', size=20)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nw, v0, v1 = eig(Ms, left=True)\\nw = w.real\\nprint '%s\\\\n%s' % (w, v0)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"5. $k$-NN classifier\\nA simple extension of the 1-NN classifier is the $k$-NN classifier, which, for any input sample ${\\\\bf x}$, computes the $k$ closest neighbors in the training set, and takes the majority class in the subset. To avoid ties, in the binary classification case $k$ is usually taken as an odd number.\\nThe following method implements the $k$-NN classifiers.\\n\",\"targets\":\"def knn_classifier(X1,Y1,X2,k):\\n \\\"\\\"\\\" Compute the k-NN classification for the observations contained in\\n the rows of X2, for the training set given by the rows in X1 and the\\n components of S1. k is the number of neighbours.\\n \\\"\\\"\\\"\\n if X1.ndim == 1:\\n X1 = np.asmatrix(X1).T\\n if X2.ndim == 1:\\n X2 = np.asmatrix(X2).T\\n distances = spatial.distance.cdist(X1,X2,'euclidean')\\n neighbors = np.argsort(distances, axis=0, kind='quicksort', order=None)\\n closest = neighbors[range(k),:]\\n \\n y_values = np.zeros([X2.shape[0],1])\\n for idx in range(X2.shape[0]):\\n y_values[idx] = np.median(Y1[closest[:,idx]])\\n \\n return y_values\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Calculate average age of team\\n\",\"targets\":\"dflfc_openers[['Season', 'AgeAtOpener']].groupby('Season').agg(lambda x: round(x.mean(), 1))\\n\\ndflfc_openers[['Season', 'AgeAtOpener']].groupby('Season').agg(lambda x: round(x.mean(), 1)).plot(kind='bar', ylim=(24,28))\\n\\ndflfc_transfers_with_dob[dflfc_transfers_with_dob.Direction == 'In'][['Season', 'Player', 'Fee', 'AgeAtTransfer']]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Please type your code here:\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nChanging case\\nWe can also change the case of a string using the built in method name. Lets see how:\\nFor uppercase, use the upper() method. In the documentation (above link) we see it listed as: str.upper()\\nnew_dna.upper()\\n\\nFor lowercase, use the lower() method.\\nnew_dna.lower()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"3\\/dlnd_tv_script_generation.ipynb\\\".\\nThe first task is:\\nNeural Network Training\\nHyperparameters\\nTune the following parameters:\\n\\nSet num_epochs to the number of epochs.\\nSet batch_size to the batch size.\\nSet rnn_size to the size of the RNNs.\\nSet seq_length to the length of sequence.\\nSet learning_rate to the learning rate.\\nSet show_every_n_batches to the number of batches the neural network should print progress.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Number of Epochs\\nnum_epochs = 80\\n# Batch Size\\nbatch_size = 23\\n# RNN Size\\nrnn_size = 256\\n# Sequence Length\\nseq_length = 33\\n# Learning Rate\\nlearning_rate = 0.005\\n# Show stats for every n number of batches\\nshow_every_n_batches = 100\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\nsave_dir = '.\\/save'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\" Vectorized String Operations<\\/h1>\\n\",\"targets\":\"movies.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Again, let's define a dictionary to collect these correction function.\\n\",\"targets\":\"dCorrectionFunc = {\\n \\\"DG\\\": dgDG,\\n \\\"SG\\\": dgSG,\\n \\\"LumpLo\\\": dgLumpLo,\\n \\\"LumpChLo\\\": dgLumpChLo,\\n \\\"Ga\\\": dgGa\\n}\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%html\\n\\nOne-way trip in DC\\n<\\/div>\\nRound trip in DC\\n<\\/div>\\nOne-way trip in NYC\\n<\\/div>\\nRound trip in NYC\\n<\\/div>\\n\\n%%javascript\\n\\n\\/\\/$(document).ready(function(){\\ndraw_heatmap(\\\".\\/data\\/dc_round_trips.tsv\\\", \\\"#dccommuter\\\");\\ndraw_heatmap(\\\".\\/data\\/dc_one_way.tsv\\\", \\\"#dcleisure\\\");\\ndraw_heatmap(\\\".\\/data\\/nyc_one_way.tsv\\\", \\\"#nyccommuter\\\");\\ndraw_heatmap(\\\".\\/data\\/nyc_round_trips.tsv\\\", \\\"#nycleisure\\\");\\n\\/\\/});\\nvar margin = { top: 50, right: 0, bottom: 100, left: 30 },\\n width = 960 - margin.left - margin.right,\\n height = 430 - margin.top - margin.bottom,\\n gridSize = Math.floor(width \\/ 24),\\n legendElementWidth = gridSize*2,\\n buckets = 9,\\n colors = [\\\"#ffffd9\\\",\\\"#edf8b1\\\",\\\"#c7e9b4\\\",\\\"#7fcdbb\\\",\\\"#41b6c4\\\",\\\"#1d91c0\\\",\\\"#225ea8\\\",\\\"#253494\\\",\\\"#081d58\\\"], \\/\\/ alternatively colorbrewer.YlGnBu[9]\\n \\/\\/ colors = [\\\"#ffffd9\\\",\\\"#edf8b1\\\",\\\"#c7e9b4\\\",\\\"#7fcdbb\\\",\\\"#41b6c4\\\",\\\"#1d91c0\\\",\\\"#225ea8\\\",\\\"#253494\\\",\\\"#081d58\\\"], \\/\\/ alternatively colorbrewer.YlGnBu[9]\\n days = [\\\"Su\\\", \\\"Mo\\\", \\\"Tu\\\", \\\"We\\\", \\\"Th\\\", \\\"Fr\\\", \\\"Sa\\\"],\\n times = [\\\"1a\\\", \\\"2a\\\", \\\"3a\\\", \\\"4a\\\", \\\"5a\\\", \\\"6a\\\", \\\"7a\\\", \\\"8a\\\", \\\"9a\\\", \\\"10a\\\", \\\"11a\\\", \\\"12a\\\", \\\"1p\\\", \\\"2p\\\", \\\"3p\\\", \\\"4p\\\", \\\"5p\\\", \\\"6p\\\", \\\"7p\\\", \\\"8p\\\", \\\"9p\\\", \\\"10p\\\", \\\"11p\\\", \\\"12p\\\"];\\nfunction draw_heatmap(source, div) {\\n d3.tsv(source,\\n function(d) {\\n return {\\n day: +d.day,\\n hour: +d.hour,\\n value: +d.count\\n };\\n },\\n function(error, data) {\\n var maxCount = d3.max(data, function (d) { return d.value; });\\n var colorScale = d3.scale.quantile()\\n .domain([0, buckets - 1, 100])\\n .range(colors);\\n var svg = d3.select(div).append(\\\"svg\\\")\\n .attr(\\\"width\\\", width + margin.left + margin.right)\\n .attr(\\\"height\\\", height + margin.top + margin.bottom)\\n .append(\\\"g\\\")\\n .attr(\\\"transform\\\", \\\"translate(\\\" + margin.left + \\\",\\\" + margin.top + \\\")\\\");\\n var dayLabels = svg.selectAll(\\\".dayLabel\\\")\\n .data(days)\\n .enter().append(\\\"text\\\")\\n .text(function (d)...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWith our styles in place, we have to define our div elements so that d3 can populate them. The code to do that is located below these images, as once again, running a cell in a notebook can apply changes retroactively. Unforutnately, due to security reasons, iPython does not allow arbitrary execution of JavaScript code unless it's on your own machine, so the code you see below must be run on your own machine to display the graphs inline. Images of the graphs are embedded after the code for viewing, though!\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"4. Write a requirements.txt file to specify additional ML code dependencies\\nThese are additional dependencies for your model code outside the deep learning containers needed for prediction explainability and the BigQuery TensorFlow IO reader.\\n\",\"targets\":\"%%writefile {MODEL_NAME}\\/requirements.txt\\nexplainable-ai-sdk==1.3.0\\ntensorflow-io==0.15.0\\npyarrow\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Download SVDD astore for use in SAS Event Stream Processing (ESP)\\nresults = s.astore.download(rstore=ysvdd_state)\\n\\n# Check details of loaded data\\ns.tableinfo()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSave SVDD astore for use in SAS Event Stream Processing\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!deepdive redo spouse_feature\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow, let's execute this UDF to get our features:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Comme pour le modèle linéaire, il faudrait construire les commandes d'aide à l'interprétation des résultats.\\nPénalisation et optimisation du paramètre par validation croisée. Il existe une fonction spécifique mais son mode d'emploi est peu documenté; GridSearchCV lui est préférée.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# grille de valeurs\\nparam=[{\\\"C\\\":[0.01,0.096,0.098,0.1,0.12,1,10]}]\\nlogit = GridSearchCV(LogisticRegression(penalty=\\\"l1\\\"),\\n param,cv=5,n_jobs=-1)\\ntitan_logitOpt=logit.fit(T_train, z_train)\\n# paramètre optimal\\ntitan_logitOpt.best_params_[\\\"C\\\"]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3. Visualizing original and snapped locations\\nTrue and snapped school locations\\n\",\"targets\":\"schools_df = spgh.element_as_gdf(ntw,\\n pp_name='schools',\\n snapped=False)\\n\\nsnapped_schools_df = spgh.element_as_gdf(ntw,\\n pp_name='schools',\\n snapped=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"As you can see, the interpolant does represent the data, in a sense. However it's a crazy-looking curve for the application. Trying too hard to reproduce all the data exactly is known as overfitting.\\nExample 3.1.2\\nHere are the 5-year temperature averages again.\\n\",\"targets\":\"year = arange(1955,2005,5)\\ny = array([ -0.0480, -0.0180, -0.0360, -0.0120, -0.0040,\\n 0.1180, 0.2100, 0.3320, 0.3340, 0.4560 ])\\nt = (year-1950)\\/10\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# assign column data to a pandas dataframe\\ndf = pd.DataFrame({'year': year_col,\\n 'month': month_col,\\n 'pagecount_all_views': pagecount_all_views_col,\\n 'pagecount_desktop_views': pagecount_desktop_views_col,\\n 'pagecount_mobile_views': pagecount_mobile_views_col,\\n 'pageview_all_views': pageview_all_views_col,\\n 'pageview_desktop_views': pageview_desktop_views_col,\\n 'pageview_mobile_views': pageview_mobile_views_col})\\n\\n# organize in correct column order\\ndf = df[['year',\\n 'month',\\n 'pagecount_all_views',\\n 'pagecount_desktop_views',\\n 'pagecount_mobile_views',\\n 'pageview_all_views',\\n 'pageview_desktop_views',\\n 'pageview_mobile_views']]\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nConvert to pandas DataFrame for easy export.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Add Noise and Estimate\\n\",\"targets\":\"# define snr and linearize it\\nEb_N0_dB = np.arange(0, 31, 2 )\\n\\nEb_N0 = 10**( Eb_N0_dB \\/ 10 ) \\nsigma2 = Eb \\/ ( 2 * Eb_N0 )\\n\\n# NOTE: sigma2 has to include the intended Eb\\/N0 as well as the actual Eb\\n# NOTE 2: since \\\"all is real\\\", sigma^2 = N0\\/2\\n\\n# initialize ber\\nber_euclidean = np.zeros_like( sigma2 )\\nber_projection = np.zeros_like( sigma2 )\\n\\n\\n# loop along snr\\nfor ind_sigma2, val_sigma2 in enumerate( sigma2 ):\\n \\n # initialize number of errors\\n numb_errors_projection = 0\\n numb_errors_euclidean = 0\\n\\n \\n # loop along realizations\\n for _n in range( N_trial ):\\n \\n bit = np.random.randint( 2 )\\n x = s[ bit ]\\n \\n # get output signal by adding noise\\n noise = np.sqrt( val_sigma2 ) * np.random.randn( N )\\n y = x + noise\\n\\n \\n # two decision criteria:\\n # - first using \\\"standard ML decision in R^n\\\" --> \\\"euclidean\\\"\\n # - second using projection as on slides --> \\\"projection\\\"\\n \\n # get decision variable\\n y_tilde = np.inner( v, y - ( s_1 + s_2 ) \\/ 2 )\\n \\n # estimate bit\\n bit_est_projection = int( y_tilde < 0 )\\n numb_errors_projection += int( bit != bit_est_projection ) \\n \\n \\n # estimate by using euclidean distance\\n bit_est_euclidean = int( np.linalg.norm( y - s_1 ) > np.linalg.norm( y - s_2 ) )\\n numb_errors_euclidean += int( bit != bit_est_euclidean )\\n\\n \\n # evaluate error rate\\n ber_projection[ ind_sigma2 ] = numb_errors_projection \\/ N_trial\\n ber_euclidean[ ind_sigma2 ] = numb_errors_euclidean \\/ N_trial\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"MandMs\\/03_Facies_classification_MandMs_feature_engineering_derivatives_moments_glcms_nofacies_data.ipynb\\\".\\nThe first task is:\\nOne last consideration for the GLCM is its symmetry. Symmetry in a GLCM refers to a bi-directional evaluation of the reference-neighbour pair. In plain English, if you were to construct a GLCM by hand, you would move through an array in one direction and then in the opposite direction. It is often desirable to do this because this removes the asymmety caused at the edge of a neighbourhood. See Mryka Hall-Beyer's tutorial for a full explanation of this. However, since sedimentary rocks (provided that they are structurally undisturbed) are laid down from bottom to top, we thought in addition to the symmetric GLCM, it would be useful to evaluate the asymmetric GLCM where we look at the neighbour above.\\nFirst let's calculate symmetric GLCM properties:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nglcm_sym_df = pd.DataFrame() # final dataframe\\ngrouped = training_data['Well Name'].unique()\\n\\nfor well in grouped: # for each well \\n new_dfg = pd.DataFrame() # make a new temporary dataframe \\n\\n for log in ['GR', 'ILD_log10', 'DeltaPHI', 'PHIND', 'PE']: # for each log\\n for me in methods: # for each property\\n # calculate rolling GLCM properties with each window size\\n # and also the mean of moments (all window sizes)\\n lg = eq_glcm_df[log][eq_glcm_df['Well Name'] == well]\\n results = np.array([gprops_calc(lg.astype(int), wd, lv = 64, sym = True, prop = me) for wd in sizes])\\n mean_result = np.mean(results, axis=0)\\n # write to temporary dataframe \\n new_dfg[str(log)+ '_GLCM_' + str(me)+'_wsize=' +str(sizes[0])] = results[0]\\n new_dfg[str(log)+ '_GLCM_' + str(me)+'_wsize=' +str(sizes[1])] = results[1]\\n new_dfg[str(log)+ '_GLCM_' + str(me)+'_wsize=' +str(sizes[2])] = results[2]\\n new_dfg[str(log)+ '_GLCM_' + str(me)+'_wsize=' +str(sizes[3])] = results[3]\\n new_dfg[str(log)+ '_GLCM_' + str(me)+'_wsize=' +str(sizes[4])] = results[4]\\n new_dfg[str(log)+ '_GLCM_' + str(me)+'_wsize=' +str(sizes[5])] = results[5]\\n new_dfg[str(log)+ '_GLCM_' + str(me)+'_wsize=' +str(sizes[6])] = results[6]\\n new_dfg[str(log)+ '_GLCM_' + str(me)+'_wsize=ave'] = mean_result\\n # append all rows of temporary dataframe to final dataframe \\n\\n glcm_sym_df = pd.concat([glcm_sym_df , new_dfg])\\n\\nglcm_sym_df.describe()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"41. Observation Simulation --> Isscp Attributes\\nISSCP Characteristics\\n41.1. Top Height Estimation Method\\nIs Required: TRUE Type: ENUM Cardinality: 1.N\\nCloud simulator ISSCP top height estimation methodUo\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# PROPERTY ID - DO NOT EDIT ! \\nDOC.set_id('cmip6.atmos.observation_simulation.isscp_attributes.top_height_estimation_method') \\n\\n# PROPERTY VALUE(S): \\n# Set as follows: DOC.set_value(\\\"value\\\") \\n# Valid Choices: \\n# \\\"no adjustment\\\" \\n# \\\"IR brightness\\\" \\n# \\\"visible optical depth\\\" \\n# \\\"Other: [Please specify]\\\" \\nDOC.set_value(\\\"IR brightness\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"18-05-28-Complete-Guide-to-Tensorflow-for-Deep-Learning-with-Python\\/02-Tensorflow-Basics\\/06-Regression-Exercise.ipynb\\\".\\nThe first task is:\\nCreate the estimator model. Use a DNNRegressor. Play around with the hidden units!\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndnn_model = tf.estimator.DNNRegressor(hidden_units = [6, 5, 5], feature_columns = feature_columns)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"4.1) OLS\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmodel = linear_model.LinearRegression()\\nols = model.fit(xtrain, ytrain)\\n\\nyhat_train = ols.predict(xtrain)\\nyhat_test = ols.predict(xtest)\\n\\nmse_train = metrics.mean_squared_error(ytrain, yhat_train)\\nmse_test = metrics.mean_squared_error(ytest, yhat_test)\\n\\nprint(\\\"MSE (Train): \\\", mse_train)\\nprint(\\\"MSE (Test) : \\\", mse_test)\\nprint(\\\"Model Score (Train):\\\", model.score(xtrain, ytrain))\\nprint(\\\"Model Score (Test) :\\\", model.score(xtest, ytest))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3. Create a Radical Pilot Session\\n\",\"targets\":\"session = rp.Session()\\nprint \\\"Session id %s\\\"%session.uid\\nc = rp.Context('ssh')\\nc.user_id = \\\"\\\"\\nsession.add_context(c)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"MillionSong_Dataset_Exploration.ipynb\\\".\\nThe first task is:\\nHaving information about the minimum, maximum, mean, median, quartiles, etc. is interesting but it is probably more informative to look at the distribution of songs per year in details.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# first we count the number of songs per year in chronological ordre.\\nsongs_per_yr = songs.year.value_counts().sort_index()\\nsongs_per_yr.head(5)\\n\\n# add missing years in the original dataset with 0\\nsongs_per_yr = songs_per_yr.reindex(index=list(range(songs.year.min(),songs.year.max())),\\n fill_value=0)\\n\\n# Visualizing the number of songs per year\\nl_col = songs_per_yr \\/ songs_per_yr.max()\\nsongs_per_yr.plot.bar(color=cm.plasma(l_col), figsize=(12,7))\\n\\nplt.xlabel('Year')\\nplt.ylabel('Number of Songs')\\nplt.title('Number of Songs vs Year');\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# df_steps.loc[mask_discharge_changed & mask_current_negative, shdr.type] = 'discharge'\\n# mask_discharge_changed = df_steps.loc[:, (shdr.charge, \\\"delta\\\")].abs() > stable_charge_limit_hard\\n# mask_current_negative = df_steps.loc[:, (shdr.current, \\\"avr\\\")] < - current_limit_value_hard\\nn3 = new_step_table.iloc[2, :]\\no3 = old_step_table.iloc[2, :]\\n\\nt1 = \\\"current_avr\\\"\\nt2 = \\\"I_avr\\\"\\n\\nprint(n3[t1] == o3[t2])\\nprint(f\\\"old value (for steptable[{t2}]): {o3[t2]}\\\")\\nprint(f\\\"new value (for steptable[{t1}]): {n3[t1]}\\\")\\n\\nprint(o3[t2] < -0.0000000000001)\\nprint(n3[t1] < -0.0000000000001)\\n\\nt1 = \\\"discharge_delta\\\"\\nt2 = \\\"Discharge_delta\\\"\\n\\nprint(n3[t1] == o3[t2])\\nprint(f\\\"old value (for steptable[{t2}]): {o3[t2]}\\\")\\nprint(f\\\"new value (for steptable[{t1}]): {n3[t1]}\\\")\\n\\nprint(o3[t2] > 2.0)\\nprint(n3[t1] > 2.0)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n```python\\nraw_limits[\\\"current_hard\\\"] = 0.0000000000001\\nraw_limits[\\\"current_soft\\\"] = 0.00001\\nraw_limits[\\\"stable_current_hard\\\"] = 2.0\\nraw_limits[\\\"stable_current_soft\\\"] = 4.0\\nraw_limits[\\\"stable_voltage_hard\\\"] = 2.0\\nraw_limits[\\\"stable_voltage_soft\\\"] = 4.0\\nraw_limits[\\\"stable_charge_hard\\\"] = 2.0\\nraw_limits[\\\"stable_charge_soft\\\"] = 5.0\\nraw_limits[\\\"ir_change\\\"] = 0.00001\\ncurrent_limit_value_hard = self.raw_limits[\\\"current_hard\\\"]\\ncurrent_limit_value_soft = self.raw_limits[\\\"current_soft\\\"]\\nstable_current_limit_hard = self.raw_limits[\\\"stable_current_hard\\\"]\\nstable_current_limit_soft = self.raw_limits[\\\"stable_current_soft\\\"]\\nstable_voltage_limit_hard = self.raw_limits[\\\"stable_voltage_hard\\\"]\\nstable_voltage_limit_soft = self.raw_limits[\\\"stable_voltage_soft\\\"]\\nstable_charge_limit_hard = self.raw_limits[\\\"stable_charge_hard\\\"]\\nstable_charge_limit_soft = self.raw_limits[\\\"stable_charge_soft\\\"]\\nir_change_limit = self.raw_limits[\\\"ir_change\\\"]\\n```\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"$$S = s \\/ \\\\sqrt{t}$$\\n$$t = \\\\left( \\\\frac{s}{S} \\\\right) ^2$$\\nPoisson distribution can be approximated as Gaussian for $n>10$ events\\n\",\"targets\":\"gam_rate = 0.1582244 * 60 # gamma \\/ hour \\ngam_err = 0.006188022 * 60 \\n#bg_rate = \\nf = 1.75\\n\\nprint(gam_rate)\\nprint(gam_err)\\nprint(gam_rate*f)\\n\\n\\nmax_exp = 3.0 # hours \\/ night \\nexposure = 3\\nassert(exposure <= max_exp)\\nnum_evts = exposure * gam_rate\\n\\nprint(num_evts)\\nprint(np.sqrt(num_evts))\\n\\n# if flux increased \\nf = 1.75\\nprint(num_evts*f)\\nstdev_f = np.sqrt(num_evts*f)\\nprint(stdev_f)\\nn_sigma = (num_evts*f-num_evts)\\/stdev_f\\n\\nprint(\\\" a flux level of \\\" + str(f) + \\\" measured for \\\" + str(exposure) + \\\" hours\\\"\\\\\\n \\\" times the average rate would be \\\" + str(n_sigma) \\\\\\n + \\\" stdevs away from the average rate\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Batches\\nImplement get_batches to create batches of input and targets using int_text. The batches should be a Numpy array with the shape (number of batches, 2, batch size, sequence length). Each batch contains two elements:\\n- The first element is a single batch of input with the shape [batch size, sequence length]\\n- The second element is a single batch of targets with the shape [batch size, sequence length]\\nIf you can't fill the last batch with enough data, drop the last batch.\\nFor exmple, get_batches([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], 3, 2) would return a Numpy array of the following:\\n```\\n[\\n # First Batch\\n [\\n # Batch of Input\\n [[ 1 2], [ 7 8], [13 14]]\\n # Batch of targets\\n [[ 2 3], [ 8 9], [14 15]]\\n ]\\n# Second Batch\\n [\\n # Batch of Input\\n [[ 3 4], [ 9 10], [15 16]]\\n # Batch of targets\\n [[ 4 5], [10 11], [16 17]]\\n ]\\n# Third Batch\\n [\\n # Batch of Input\\n [[ 5 6], [11 12], [17 18]]\\n # Batch of targets\\n [[ 6 7], [12 13], [18 1]]\\n ]\\n]\\n```\\nNotice that the last target value in the last batch is the first input value of the first batch. In this case, 1. This is a common technique used when creating sequence batches, although it is rather unintuitive.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef get_batches(int_text, batch_size, seq_length):\\n \\\"\\\"\\\"\\n Return batches of input and target\\n :param int_text: Text with the words replaced by their ids\\n :param batch_size: The size of batch\\n :param seq_length: The length of sequence\\n :return: Batches as a Numpy array\\n \\\"\\\"\\\"\\n a = np.array(int_text)\\n n_batches = int(len(a) \\/ batch_size \\/ seq_length) \\n shp = (n_batches, 2, batch_size, seq_length)\\n\\n n = a.strides[0]\\n s = np.lib.stride_tricks.as_strided\\n strides=(shp[3]*n, n, shp[0]*shp[3]*n, n)\\n out = s(a, shp, strides=strides)\\n out[-1,1,-1][-1] = out[0,0,0,0] # Satisfy last value of last batch = first value of first batch constraint\\n return out\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_get_batches(get_batches)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Configure the job\\n\",\"targets\":\"# dataset name is the ticker\\nds_name = \\\"SPY\\\"\\n\\n# Label and description for job\\ntitle = str(ds_name) + \\\" Forecast v5 - \\\" + str(uni_key())\\ndesc = \\\"Forecast simulation - \\\" + str(datetime.datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\"))\\n\\n# Whats the algorithm model you want to use?\\nalgo_name = \\\"xgb-regressor\\\"\\n\\n# If your dataset is stored in redis, you can pass in the location\\n# to the dataset like: :\\nrloc = \\\"\\\" \\n\\n# If your dataset is stored in S3, you can pass in the location \\n# to the dataset like: :\\nsloc = \\\"\\\" \\n\\n# During training what ratio of tests-vs-training do you want to use?\\n# Trade off smarts vs accuracy...how smart are we going?\\ntest_ratio = 0.1\\n\\n# Customize dataset samples used during the analysis using json dsl\\nsample_filter_rules = {}\\n\\n# What column do you want to predict values?\\ntarget_column_name = \\\"FClose\\\"\\n\\n# What columns can the algorithms use for training and learning?\\nfeature_column_names = [ \\\"FHigh\\\", \\\"FLow\\\", \\\"FOpen\\\", \\\"FClose\\\", \\\"FVolume\\\" ]\\n\\n# values in the Target Column\\ntarget_column_values = [ \\\"GoodBuys\\\", \\\"BadBuys\\\", \\\"Not Finished\\\" ] \\n\\n# How many units ahead do you want to forecast?\\nunits_ahead_set = [ 5, 10, 15, 20, 25, 30 ]\\nunits_ahead_type = \\\"Days\\\"\\n\\n# Prune non-int\\/float columns as needed: \\nignore_features = [ \\n \\\"Ticker\\\",\\n \\\"Date\\\",\\n \\\"FDate\\\",\\n \\\"FPrice\\\",\\n \\\"DcsnDate\\\",\\n \\\"Decision\\\"\\n ]\\n\\n# Set up the XGB parameter\\n# https:\\/\\/github.com\\/dmlc\\/xgboost\\/blob\\/master\\/doc\\/parameter.md\\ntrain_xgb = {\\n \\\"learning_rate\\\" : 0.20, \\n \\\"num_estimators\\\" : 50, \\n \\\"sub_sample\\\" : 0.20, \\n \\\"col_sample_by_tree\\\" : 0.90, \\n \\\"col_sample_by_level\\\" : 1.0, \\n \\\"objective\\\" : \\\"reg:linear\\\",\\n \\\"max_depth\\\" : 3,\\n \\\"max_delta_step\\\" : 0,\\n \\\"min_child_weight\\\" : 1, \\n \\\"reg_alpha\\\" : 0, \\n \\\"reg_lambda\\\" : 1,\\n \\\"base_score\\\" : 0.6,\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"SAMPLE SOLUTION:<\\/font><\\/b>\\nUn-comment and execute the following, to view a possible solution, and some code.\\nThen run it ...\\n\",\"targets\":\"# SAMPLE SOLUTION\\n# %load solutions\\/iris_exercise_1.2a\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"P3.Python_datos\\/Old\\/Data_python_professor.ipynb\\\".\\nThe first task is:\\n4.2 Train\\/Test splitting\\nNow, we are about to start doing machine learning. But, first of all, we have to separate our data in train and test partitions.\\nThe train data will be used to adjust the parameters (train) of our model.\\nThe test data will be used to evaluate our model.\\nUse sklearn.cross_validation.train_test_split to split the data in train (60%) and test (40%). Save the results in variables named X_train, X_test, y_train, y_test.\\nImportant note\\nIn real applications, you would have no access to any targets for the test data. However, for illustratory purposes, when evaluating machine learning algorithms it is common to set aside a test partition, including the corresponding labels, so that you can use these targets to assess the performance of the method. When proceeding in this way, the test labels should never be used during the design. It is just allowed to use them as a final assessment step once the classifier or regression model has been fully adjusted.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#\\nX_train, X_test, y_train, y_test = train_test_split( X_com, y_com, test_size=0.4)\\n#<\\/SOL>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# now do the same thing for rois\\nrois_data = nib.load(cc200_nii).get_data()\\n\\nprint(rois_data.shape)\\n\\nif rois_data.shape[0:2] == dims[0:2]:\\n print(\\\"ROIs and func file dimensions match, Hooray!!\\\")\\nelse:\\n print(\\\"FAIL, they do not match\\\")\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCheckling that our functional and mask files have the same dimensions...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#Plot a histogram of the average rating for each movie.\\nAvg_rating_each=data.pivot_table('rating',index='title',aggfunc='mean')\\nAvg_rating_each.hist(color='orange')\\nplt.title('Histogram of Average rating for each movie')\\nplt.ylabel('Number of Movies')\\nplt.xlabel('Average Rating')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPlot a histogram of the average rating for each movie.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"DM\\/DataMining\\/hw0.ipynb\\\".\\nThe first task is:\\nd. in \\/ out flow -mean\\/std lin chart and distance\\nCan you write Python code for it?\\n\",\"targets\":\"\\nplt.figure()\\naxes = plt.gca()\\naxes.set_ylim([-5,10])\\nin_most.sub(in_most.mean()).divide(in_most.std()).plot(figsize=(15, 5))\\nout_most.sub(out_most.mean()).divide(out_most.std()).plot(figsize=(15, 5))\\nplt.show()\\n#print(in_most.mean(), in_most.std())\\n#print(out_most.mean(), out_most.std())\\npairwise.pairwise_distances(np.array([in_most.sub(in_most.mean()).divide(in_most.std()).tolist(), out_most.sub(out_most.mean()).divide(out_most.std()).tolist()]), metric='minkowski', n_jobs=4, p=2)[0][1]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.13\\/_downloads\\/plot_creating_data_structures.ipynb\\\".\\nThe first task is:\\nCreating :class:Info <mne.Info> objects\\nNote<\\/h4>for full documentation on the `Info` object, see\\n `tut_info_objects`. See also\\n `sphx_glr_auto_examples_io_plot_objects_from_arrays.py`.<\\/p><\\/div>\\n\\nNormally, :class:mne.Info objects are created by the various\\ndata import functions <ch_convert>.\\nHowever, if you wish to create one from scratch, you can use the\\n:func:mne.create_info function to initialize the minimally required\\nfields. Further fields can be assigned later as one would with a regular\\ndictionary.\\nThe following creates the absolute minimum info structure:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Create some dummy metadata\\nn_channels = 32\\nsampling_rate = 200\\ninfo = mne.create_info(32, sampling_rate)\\nprint(info)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"BGS, ELG, LRG, QSO, LYA, MWS_NEARBY, WD, SKY\\nThese mocks are are one single mock catalog, so MOCKID will provide the row of each target in the original, unfiltered parent catalog. Here, we demonstrate how to navigate the input and output files using the BGS mock.\\nFor simplicity we show how to compare the input and output celestial coordinates and the redshifts, although obviuosly other properties are available in the parent mock.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef read_bgs_mock():\\n import h5py\\n mockfile = class2mockfile['BGS'].format(**os.environ)\\n print('Reading {}'.format(mockfile))\\n with h5py.File(mockfile, mode='r') as f:\\n ra = f['Data\\/ra'][:].astype('f8') % 360.0 # enforce 0 < ra < 360\\n dec = f['Data\\/dec'][:].astype('f8')\\n zobs = f['Data\\/z_obs'][:].astype('f4') \\n return ra, dec, zobs\\n\\n%time ra, dec, zobs = read_bgs_mock()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Group events by \\\"PID\\\" and compute \\nmost_switching = df.groupby('next_pid').describe(include=['object'])\\nmost_switching.head()\\n\\nmost_switching = most_switching.unstack()\\nmost_switching.head()\\n\\nmost_switching = most_switching['next_comm']\\\\\\n .sort_values(by=['count'], ascending=False)\\nmost_switching.head()\\n\\nmost_switching_pid = most_switching.index[1]\\nmost_switching_task = most_switching.values[1][2]\\ntask_name = \\\"{}:{}\\\".format(most_switching_pid, most_switching_task)\\nlogging.info(\\\"The second most swithing task is: [%s]\\\", task_name)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nEvents grouping\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A continuación, lo siguiente que tenemos que hacer es crear un enjambre de hormigas. Con esta función, lo podremos hacer fácilmente.\\n\",\"targets\":\"map1.swarm_create(100) # Creamos un enjambre de 100 hormigas\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"1 Counter\\nA Counter is a dict subclass for counting hashable objects. It is an unordered collection where elements are stored as dictionary keys and their counts are stored as dictionary values.\\n1.1 construction\\n\",\"targets\":\"c1 = Counter()\\nc2 = Counter('gaufung')\\nc3 = Counter({'red':4,'blue':10})\\nc4 = Counter(cats=4,dogs=5)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#I import the environmental characteristics data file\\n\\n#Same thing with the filepath here.\\npitch=pd.read_table('..\\/data\\/pitches.csv', sep=',')\\n\\n#I display my dataframe\\npitch\\n\\n# If you look at the end of your table (lines 54 to 56), the columns are shifted. \\n# You need to fix this first, especially because you want to work with the 2010-04-17 date. \\n# To fix this, first isolate the last 3 rows that you need to fix. \\n\\npitch2 = pitch.ix[54:]\\npitch2\\n\\n# Now you need to drop the first column with the NaN values\\n\\npitch3 = pitch2.drop('time', axis=1)\\npitch3\\n\\n# Now you need to rename your columns\\npitch3.columns = [['time', 'div', 'note', 'freq1', 'freq2', 'freq3', 'freq4', 'freq5', 'freq6', 'freq7', 'freq8']]\\npitch3\\n\\n# Now you can merge this fixed data back with the original data frame and delete the old rows containing this data\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow I know that my datetime column is read as an actually date and time value (a function of Python), and not as an object or string, as it was before performing the \\\"datetime\\\" operation.\\nNow, I will upload the pitch data so I can compare change in pitch of certain notes and change in environmental characteristics.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%bash\\nOUTDIR=gs:\\/\\/${BUCKET}\\/fashion\\/trained_${MODEL_TYPE}\\nJOBNAME=fashion_${MODEL_TYPE}_$(date -u +%y%m%d_%H%M%S)\\necho $OUTDIR $REGION $JOBNAME\\ngsutil -m rm -rf $OUTDIR\\ngcloud ml-engine jobs submit training $JOBNAME \\\\\\n --region=$REGION \\\\\\n --module-name=trainer.task \\\\\\n --package-path=${PWD}\\/fashionmodel\\/trainer \\\\\\n --job-dir=$OUTDIR \\\\\\n --staging-bucket=gs:\\/\\/$BUCKET \\\\\\n --scale-tier=BASIC_GPU \\\\\\n --runtime-version=$TFVERSION \\\\\\n -- \\\\\\n --output_dir=$OUTDIR \\\\\\n --train_steps=10000 --learning_rate=0.01 --train_batch_size=512 \\\\\\n --model=$MODEL_TYPE\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nMake sure that local training completed successfully before training using Cloud ML Engine\\nNote that GPU speed up depends on the model type. You'll notice that more complex models train substantially faster on GPUs. When you are working with simple models that take just seconds to minutes to train on a single node, keep in mind that Cloud ML Engine introduces a few minutes of overhead for training job setup & teardown.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Notebooks\\/1-Your first steps .ipynb\\\".\\nThe first task is:\\nLet's break down what happened there. To do that we must go to the innermost part of the statement, the part where we are using the plus sign. We are adding the string at the first position in dir_of_root to the string in root_root. If you don't understand how that works, try doing it:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nroot_root+dir_of_root[0]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Attribute Information:\\n\\nNo: row number \\nyear: year of data in this row \\nmonth: month of data in this row \\nday: day of data in this row \\nhour: hour of data in this row \\npm2.5: PM2.5 concentration (ug\\/m^3) \\nDEWP: Dew Point (ƒ) \\nTEMP: Temperature (ƒ) \\nPRES: Pressure (hPa) \\ncbwd: Combined wind direction \\nIws: Cumulated wind speed (m\\/s) \\nIs: Cumulated hours of snow \\nIr: Cumulated hours of rain\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npm2 = pd.read_csv('http:\\/\\/archive.ics.uci.edu\\/ml\\/machine-learning-databases\\/00381\\/PRSA_data_2010.1.1-2014.12.31.csv',\\n na_values='NA')\\npm2.columns = ['id', 'year', 'month', 'day', 'hour', 'pm2', 'dew_point', 'temperature',\\n 'pressure', 'wind_dir', 'wind_speed', 'hours_snow', 'hours_rain']\\n\\npm2.head()\\n\\npm2.info()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%matplotlib inline\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n오늘의 주요 예제 해결\\n$y = x^2$ 함수의 그래프를 그리고자 한다. \\n그래프를 그리기 위해 matplotlib.pyplot 이란 모듈을 이용한다. \\n아래 코드처럼 퍼센트 기호(%)로 시작하는 코드는 쥬피터 노트북에만 사용하는 코드이며,\\n아래 코드는 쥬피터 노트북에 그래프를 직접 나타내기 위해 사용한다.\\nspyder 등 파이썬 에디터를 사용하는 경우 필요하지 않는 코드이다.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Cap05\\/Notebooks\\/DSA-Python-Cap05-02-Objetos.ipynb\\\".\\nThe first task is:\\nObjetos\\nEm Python, tudo é objeto!\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Criando uma lista\\nlst_num = [\\\"Data\\\", \\\"Science\\\", \\\"Academy\\\", \\\"Nota\\\", 10, 10]\\n\\n# A lista lst_num é um objeto, uma instância da classe lista em Python\\ntype(lst_num)\\n\\nlst_num.count(10)\\n\\n# Usamos a função type, para verificar o tipo de um objeto\\nprint(type(10))\\nprint(type([]))\\nprint(type(()))\\nprint(type({}))\\nprint(type('a'))\\n\\n# Criando um novo tipo de objeto chamado Carro\\nclass Carro(object):\\n pass\\n\\n# Instância do Carro\\npalio = Carro()\\n\\nprint(type(palio))\\n\\n# Criando uma classe\\nclass Estudantes:\\n def __init__(self, nome, idade, nota):\\n self.nome = nome\\n self.idade = idade\\n self.nota = nota\\n\\n# Criando um objeto chamado Estudante1 a partir da classe Estudantes\\nEstudante1 = Estudantes(\\\"Pele\\\", 12, 9.5)\\n\\n# Atributo da classe Estudante, utilizado por cada objeto criado a partir desta classe\\nEstudante1.nome\\n\\n# Atributo da classe Estudante, utilizado por cada objeto criado a partir desta classe\\nEstudante1.idade\\n\\n# Atributo da classe Estudante, utilizado por cada objeto criado a partir desta classe\\nEstudante1.nota\\n\\n# Criando uma classe\\nclass Funcionarios:\\n def __init__(self, nome, salario):\\n self.nome = nome\\n self.salario = salario\\n\\n def listFunc(self):\\n print(\\\"O nome do funcionário é \\\" + self.nome + \\\" e o salário é R$\\\" + str(self.salario))\\n\\n# Criando um objeto chamado Func1 a partir da classe Funcionarios\\nFunc1 = Funcionarios(\\\"Obama\\\", 20000)\\n\\n# Usando o método da classe\\nFunc1.listFunc()\\n\\nprint(\\\"**** Usando atributos *****\\\")\\n\\nhasattr(Func1, \\\"nome\\\")\\n\\nhasattr(Func1, \\\"salario\\\")\\n\\nsetattr(Func1, \\\"salario\\\", 4500)\\n\\nhasattr(Func1, \\\"salario\\\")\\n\\ngetattr(Func1, \\\"salario\\\")\\n\\ndelattr(Func1, \\\"salario\\\")\\n\\nhasattr(Func1, \\\"salario\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"ANTLR4-Python\\/Interpreter\\/Interpreter-Matching.ipynb\\\".\\nThe first task is:\\nThe function evaluate takes two arguments:\\n- expr is a logical expression or an arithmetic expression,\\n- Values is a dictionary assigning integer values to variable names.\\nThe function evaluates the given expression and returns this value.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef evaluate(expr, Values):\\n match expr:\\n case int(expr):\\n return expr\\n case str(expr):\\n return Values[expr] \\n case ('read',):\\n return int(input('Please enter a natural number: '))\\n case ('==', lhs, rhs):\\n return evaluate(lhs, Values) == evaluate(rhs, Values)\\n case ('<', lhs, rhs):\\n return evaluate(lhs, Values) < evaluate(rhs, Values)\\n case ('+', lhs, rhs):\\n return evaluate(lhs, Values) + evaluate(rhs, Values)\\n case ('-', lhs, rhs):\\n return evaluate(lhs, Values) - evaluate(rhs, Values)\\n case ('*', lhs, rhs):\\n return evaluate(lhs, Values) * evaluate(rhs, Values)\\n case ('\\/', lhs, rhs):\\n return evaluate(lhs, Values) \\/ evaluate(rhs, Values)\\n case _:\\n assert False, f'{expr} unexpected'\\n\\n!type sum.sl\\n\\n!cat sum.sl\\n\\nmain('sum.sl')\\n\\n!type factorial.sl\\n\\n!cat factorial.sl\\n\\nmain('factorial.sl')\\n\\n!del *.py *.tokens *.interp\\n!del *.pdf\\n!del ast\\n\\n!rmdir \\/Q \\/S __pycache__\\n\\n!dir \\/B\\n\\n!rm *.py *.tokens *.interp\\n!rm ast\\n!rm -r __pycache__\\/\\n!rm *.pdf\\n\\n!ls\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Da das gewählte Element wieder eine Liste ist, können wir auch auf einzelne Element zugreifen. Den ersten Messwert des zweiten Tages erhalten wir so:\\n\",\"targets\":\"temperatures[1][0]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!ls -lh *\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLet's take a look at what we've got\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"05其他\\/pandas文档-zh-master\\/数据合并、连接和拼接-Merge, join, and concat.ipynb\\\".\\nThe first task is:\\n注意到结果中的索引是层次化的。\\nCan you write Python code for it?\\n\",\"targets\":\"\\nresult.ix['y'] #查看df2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Backbone\\nDetects and fixes several problems with the backbone\\nuse any of \\n--fix_atoms All|None|Residue List \\n--fix_chain All|None|Break list\\n--add_caps All|None|Terms|Breaks|Residue list\\n--no_recheck\\n--no_check_clashes\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nst_c.backbone()\\n\\nst_c.backbone('--fix_atoms All --fix_chain none --add_caps none')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"As can be seen in the above the class object is organized here, and hence for better results, I start with randomly shuffling the data.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntelescope_shuffle=telescope.iloc[np.random.permutation(len(telescope))]\\ntelescope_shuffle.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%load_ext rpy2.ipython \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLine magics\\nIPython has an rmagic extension that contains a some magic functions for working with R via rpy2. This extension can be loaded using the %load_ext magic as follows:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create an empty init.py file required to be in the container\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport os\\n\\nwith open(os.path.join(\\\"trainer\\\", \\\"__init__.py\\\"), \\\"w\\\") as fp:\\n pass\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Day_01\\/01_Advanced_Python\\/03_LambdaFunction-Solutions.ipynb\\\".\\nThe first task is:\\nProblem 2<\\/u>\\nUse the filter function to remove all the vowels from the sentence\\nCan you write Python code for it?\\n\",\"targets\":\"\\nsentence = \\\"It's a myth that there are no words in English without vowels.\\\"\\nvowels = 'aeiou' \\n\\nresult = filter(lambda x: x not in vowels, sentence)\\nprint result\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Age Swamplot\\nSeaborn<\\/a> has some cool canned functions for examining data distributions by category. I am particuraly fond sns.swarmplot that makes plots like the one below. The plot is a sampling of the distribution of first 1000 rows by region and poster age. Strangely, there are a few posters with ages around 100 years old.\\n\",\"targets\":\"import seaborn as sns\\n%matplotlib inline\\nfrom pylab import rcParams\\nrcParams['figure.figsize'] = (7.0, 7.0)\\n\\nsns.swarmplot(y='region',x='posterage',data=df.head(1000),size=2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"By default, TFX ExampleGen divides examples into two splits, train and\\neval, but you can\\nadjust your split configuration.\\nExamine output from StatisticsGen\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nvisualize_artifacts(stats_artifacts)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Bursts Counts\\nDexAem Counts\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nvar = 'na'\\nsize_th = 15\\nfig, ax = plt.subplots(1, 2, figsize=(11, 4.5), sharey=True, sharex=True)\\nplt.subplots_adjust(hspace=0.05)\\n#kws = dict(marker='o', ls='')\\nkws = dict(lw=lw)\\nvar_labels = dict(na='DexAem', nd='DexDem')\\n\\nbins = np.arange(0, 350, 5)\\nx = bins[:-1] + 0.5*(bins[1] - bins[0])\\nfor ich in range(8):\\n for i, s in enumerate(samples[:]):\\n bursts = BurstsM[s]\\n bursts = bursts.loc[bursts.ich == ich]\\n color = colors[i]\\n sizes = bursts.na + bursts.nd * gammaM\\n mask = (sizes > size_th)\\n data = bursts.loc[mask, var]\\n counts, bins = np.histogram(data, bins, normed=True)\\n if ich == 0:\\n ax[1].plot([], label=s, **kws) # empty lines for the legend\\n counts[counts == 0] = np.nan # break lines at zeros in log-scale\\n ax[1].plot(x, counts, color=color, alpha=0.5, **kws)\\n \\n if ich == 0 and 'DO' not in s:\\n bursts = BurstsA[s]\\n sizes = bursts.na + bursts.nd * gammaA\\n mask = (sizes > size_th)\\n data = bursts.loc[mask, var]\\n counts, bins = np.histogram(data, bins, normed=True)\\n counts[counts == 0] = np.nan # break lines at zeros\\n ax[0].plot(x, counts, color=color, label=label, **kws)\\n \\nplt.yscale('log')\\nplt.ylim(1e-4)\\nif var == 'na':\\n plt.xlim(0, 140)\\nax[1].legend(title='Sample')\\nfor a in ax:\\n sns.despine(ax=a)\\n #a.set_title('DexAem Burst Size Distribution')\\n a.set_xlabel('Photon Counts (%s)' % var_labels[var])\\ntitle_kw = dict(fontdict={'verticalalignment': 'top'}, fontsize=18)\\nax[0].set_title('μs-ALEX', **title_kw)\\nax[1].set_title('Multispot', **title_kw);\\nsavefig('%s distribution usALEX vs multispot, size_th=%d' % (var, size_th))\\nsavefig('%s distribution usALEX vs multispot, size_th=%d.svg' % (var, size_th))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Cpp\\/Cpp14\\/FileIO\\/FileIO.ipynb\\\".\\nThe first task is:\\nWhitespace separated, or \\nno header\\ncf. Manufacturing Learning Curves\\nCan you write Python code for it?\\n\",\"targets\":\"\\nManu_learn = pd.read_csv(datafilefolder+\\\"manuf_learn.dat\\\",header=None,delim_whitespace=True)\\n\\nManu_learn\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3 Ejercicio\\nLa función farenToCentig convierte grados Farenheit en grados centígrados. \\n* Utiliza la función farenToCentig para generar la siguiente tabla de conversión:\\n0:º F = -18.0º C\\n10:º F = -13.0º C\\n20:º F = -7.0º C\\n ...\\n100:º F = 37.0º C\\n110:º F = 43.0º C\\n120:º F = 48.0º C\\nNota:\\n* Genera la lista de valores $[0, ... , 120]$ con la función range.\\n* Utiliza un bucle for para calcular los grados centígrados de cada elemento de la lista de valores.\\n\",\"targets\":\"# Sol :\\nF = list(range(0,130,10))\\ndef farenToCentig(F):\\n return (F-32)*(5\\/9) \\n\\nfor i in F:\\n cent = farenToCentig(i)\\n conversion = round(cent)\\n print( '%d ºF = %.1f ºC' % (i,conversion))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"A validation set can be used to assess how well the model is performing. A low accuracy on the training and validation\\nsets imply underfitting. A high accuracy on the training set but low accuracy on the validation set implies overfitting.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n### Train your model here.\\n### Calculate and report the accuracy on the training and validation set.\\n### Once a final model architecture is selected, \\n### the accuracy on the test set should be calculated and reported as well.\\n### Feel free to use as many code cells as needed.\\n\\n#Features and Labels\\nx = tf.placeholder(tf.float32, (None, 32, 32, 3))\\ny = tf.placeholder(tf.int32, (None))\\none_hot_y = tf.one_hot(y, 43)\\n\\nprint(\\\"start\\\")\\n\\n#Training Pipeline\\nrate = 0.0025 # SMCM decreased rate to .0008 from 0.001\\n\\nlogits = LeNet(x)\\ncross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=one_hot_y, logits=logits)\\nloss_operation = tf.reduce_mean(cross_entropy)\\noptimizer = tf.train.AdamOptimizer(learning_rate = rate)\\ntraining_operation = optimizer.minimize(loss_operation)\\n\\ncorrect_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(one_hot_y, 1))\\naccuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\\nsaver = tf.train.Saver()\\n\\n#Model Evaluation\\ndef evaluate(X_data, y_data):\\n num_examples = len(X_data)\\n total_accuracy = 0\\n sess = tf.get_default_session()\\n for offset in range(0, num_examples, BATCH_SIZE):\\n batch_x, batch_y = X_data[offset:offset+BATCH_SIZE], y_data[offset:offset+BATCH_SIZE]\\n accuracy = sess.run(accuracy_operation, feed_dict={x: batch_x, y: batch_y})\\n total_accuracy += (accuracy * len(batch_x))\\n return total_accuracy \\/ num_examples\\n\\n#Train the Model\\n\\nwith tf.Session() as sess:\\n sess.run(tf.global_variables_initializer())\\n num_examples = len(X_train)\\n \\n print(\\\"Training...\\\")\\n print()\\n for i in range(EPOCHS):\\n X_train, y_train = shuffle(X_train, y_train)\\n for offset in range(0, num_examples, BATCH_SIZE):\\n end = offset + BATCH_SIZE\\n batch_x, batch_y = X_train[offset:end], y_train[offset:end]\\n sess.run(training_operation, feed_dict={x: batch_x, y: batch_y})\\n \\n \\n validation_accuracy = evaluate(norm_X_valid, y_valid)\\n print(\\\"EPOCH {} ...\\\".format(i+1))\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Get the counts of each of the unique hashs of our splitting column\\nfirst_bucketing_query = \\\"\\\"\\\"\\nSELECT\\n hash_values,\\n COUNT(*) AS num_records\\nFROM\\n ({CTE_data})\\nGROUP BY\\n hash_values\\n\\\"\\\"\\\".format(CTE_data=data_query)\\n\\ndisplay_dataframe_head_from_query(first_bucketing_query)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe next query is going to find the counts of each of the unique 657484 hash_values. This will be our first step at making actual hash buckets for our split via the GROUP BY.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create Data\\n\",\"targets\":\"# Create a list of 20 observations drawn from a random distribution \\n# with mean 1 and a standard deviation of 1.5\\nx = np.random.normal(1, 1.5, 20)\\n\\n# Create a list of 20 observations drawn from a random distribution \\n# with mean 0 and a standard deviation of 1.5\\ny = np.random.normal(0, 1.5, 20)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Before you begin\\nSet up your Google Cloud project\\nThe following steps are required, regardless of your notebook environment.\\n\\n\\nEnable the Vertex AI API and Compute Engine API. \\n\\n\\nIf you are running this notebook locally, you will need to install the Cloud SDK.\\n\\n\\nEnter your project ID in the cell below. Then run the cell to make sure the\\nCloud SDK uses the right project for all the commands in this notebook.\\n\\n\\nNote: Jupyter runs lines prefixed with ! as shell commands, and it interpolates Python variables prefixed with $ into these commands.\\nSet your project ID\\nIf you don't know your project ID, you may be able to get your project ID using gcloud.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport os\\n\\nPROJECT_ID = \\\"qwiklabs-gcp-01-17ee7907a406\\\" # Replace your project id here \\n\\n# Get your Google Cloud project ID from gcloud\\nif not os.getenv(\\\"IS_TESTING\\\"):\\n shell_output = !gcloud config list --format 'value(core.project)' 2>\\/dev\\/null\\n PROJECT_ID = shell_output[0]\\n print(\\\"Project ID: \\\", PROJECT_ID)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# displays the first few rows of the table\\ndata.head(4)\\n\\n# Set variables for scatter plot\\nx = data.Population\\ny = data.WaterUsed\\n\\nfig = plt.figure(figsize=(15, 6))\\nplt.scatter(x,y)\\nplt.xlim(0,3000000)\\nplt.ylim(0,350)\\nplt.title('The Relationship Between Population and How Much Water a County Consumes Each Year')\\nplt.xlabel('Population (individuals)')\\nplt.ylabel('Water Used (million gallons)')\\n\\n# This actually shows the plot\\nplt.show()\\n\\n# Creates a new dataset for County\\n\\nplace = data.groupby(\\\"County\\\", as_index = False).sum()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPre-Questions\\n\\nUsing what you've learned in this unit, answer questions 1 & 2 in your coding booklet. The Pre-Questions are listed below for you convienence.\\n\\nAccess to freshwater is a limiting factor in many ecosystems, what are some\\nother limiting factors that can effect native populations?\\nDraw a diagram that shows a lake water source. Add and label arrows for\\nways that water can be added to the lake. Add and label arrows for the ways\\nthat water can be removed from the lake. (Be sure to include human and\\nnatural \\/ non-human sources)\\n\\n\\nPART 1: Water Used by Florida Counties in 2010\\n\\nThis table displays the County name, its population, the puplic water supply for that county, and the total water used by that county.\\nUse and modify the sections of code below for Part 1 to answer questions 3-5 in your coding booklet.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Conversion factor from 758nm to 740nm is roughly 1.55 (we can provide shapes if needed)\\nplt.errorbar(dates, iowa_timeseries_oco2.mean*fac,yerr=iowa_timeseries_oco2.standard_error*fac, label='OCO-2 Mean')\\nplt.errorbar(dates, iowa_timeseries_tropomi.mean,yerr=iowa_timeseries_tropomi.standard_error, label='TROPOMI Mean')\\nplt.ylabel('SIF @740nm (W\\/m$^2$\\/sr\\/$\\\\mu$m)')\\nplt.legend(loc=0)\\nplt.title('Iowa Timeseries, +\\/-3 day running mean')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow we can use the factor to better match the 2 time-series:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2015-10_Lecture\\/Lecture2\\/code\\/2_MNIST_solution.ipynb\\\".\\nThe first task is:\\nTime to train the model\\nNow we can train our model by calling train_model(mini_batch_index). To predict labels, we can use the function predict_labels(data).\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnumber_of_minibatches = len(train_x) \\/ batch_size\\nprint \\\"%d mini batches\\\" % (number_of_minibatches)\\n\\nnumber_of_epochs = 10\\nprint \\\"%d epochs\\\" % number_of_epochs\\n\\n#\\ndef compute_accurarcy(dataset_x, dataset_y): \\n predictions = predict_labels(dataset_x)\\n errors = sum(predictions != dataset_y) #Number of errors\\n accurarcy = 1 - errors\\/float(len(dataset_y))\\n return accurarcy\\n\\nfor epoch in xrange(number_of_epochs):\\n #Train the model on all mini batches\\n for idx in xrange(0, number_of_minibatches):\\n train_model(idx)\\n \\n\\n accurarcy_dev = compute_accurarcy(dev_x, dev_y)\\n accurarcy_test = compute_accurarcy(test_x, test_y)\\n\\n print \\\"%d epoch: Accurarcy on dev: %f, accurarcy on test: %f\\\" % (epoch, accurarcy_dev, accurarcy_test)\\n \\nprint \\\"DONE\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3.4 Setting up Flow Parameters\\nRLlib and rllab experiments both generate a params.json file for each experiment run. For RLlib experiments, the parameters defining the Flow scenario and environment must be stored as well. As such, in this section we define the dictionary flow_params, which contains the variables required by the utility function make_create_env. make_create_env is a higher-order function which returns a function create_env that initializes a Gym environment corresponding to the Flow scenario specified.\\n\",\"targets\":\"# Creating flow_params. Make sure the dictionary keys are as specified. \\nflow_params = dict(\\n # name of the experiment\\n exp_tag=name,\\n # name of the flow environment the experiment is running on\\n env_name=env_name,\\n # name of the scenario class the experiment uses\\n scenario=scenario_name,\\n # simulator that is used by the experiment\\n simulator='traci',\\n # sumo-related parameters (see flow.core.params.SumoParams)\\n sim=sumo_params,\\n # environment related parameters (see flow.core.params.EnvParams)\\n env=env_params,\\n # network-related parameters (see flow.core.params.NetParams and\\n # the scenario's documentation or ADDITIONAL_NET_PARAMS component)\\n net=net_params,\\n # vehicles to be placed in the network at the start of a rollout \\n # (see flow.core.vehicles.Vehicles)\\n veh=vehicles,\\n # (optional) parameters affecting the positioning of vehicles upon \\n # initialization\\/reset (see flow.core.params.InitialConfig)\\n initial=initial_config\\n)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"IMD0104 - PROGRAMAÇÃO ORIENTADA A OBJETOS E MAPEAMENTO OBJETO-RELACIONAL\\/assignments\\/3\\/.ipynb_checkpoints\\/all-that-you-need-to-know-about-the-android-market-checkpoint.ipynb\\\".\\nThe first task is:\\nGenerally, most apps do well with an average rating of 4.17.\\nLet's break this down and inspect if we have categories which perform exceptionally good or bad.\\nApp ratings across categories - One Way Anova Test\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport scipy.stats as stats\\nf = stats.f_oneway(df.loc[df.Category == 'BUSINESS']['Rating'].dropna(), \\n df.loc[df.Category == 'FAMILY']['Rating'].dropna(),\\n df.loc[df.Category == 'GAME']['Rating'].dropna(),\\n df.loc[df.Category == 'PERSONALIZATION']['Rating'].dropna(),\\n df.loc[df.Category == 'LIFESTYLE']['Rating'].dropna(),\\n df.loc[df.Category == 'FINANCE']['Rating'].dropna(),\\n df.loc[df.Category == 'EDUCATION']['Rating'].dropna(),\\n df.loc[df.Category == 'MEDICAL']['Rating'].dropna(),\\n df.loc[df.Category == 'TOOLS']['Rating'].dropna(),\\n df.loc[df.Category == 'PRODUCTIVITY']['Rating'].dropna()\\n )\\n\\nprint(f)\\nprint('\\\\nThe p-value is extremely small, hence we reject the null hypothesis in favor of the alternate hypothesis.\\\\n')\\n#temp = df.loc[df.Category.isin(['BUSINESS', 'DATING'])]\\n\\ngroups = df.groupby('Category').filter(lambda x: len(x) > 286).reset_index()\\narray = groups['Rating'].hist(by=groups['Category'], sharex=True, figsize=(20,20))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\".ipynb_checkpoints\\/TextModels-checkpoint.ipynb\\\".\\nThe first task is:\\nCanned input data\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom keras.datasets import imdb\\n\\n(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_words) # limits vocab to num_words\\n\\n?imdb.load_data\\n\\nfrom keras.preprocessing import sequence\\n\\nx_train = sequence.pad_sequences(x_train, maxlen=sequence_length, padding=\\\"post\\\", truncating=\\\"post\\\")\\nx_test = sequence.pad_sequences(x_test, maxlen=sequence_length, padding=\\\"post\\\", truncating=\\\"post\\\")\\n\\nx_train[0]\\n\\nvocabulary = imdb.get_word_index() # word to integer map\\n\\nvocabulary['good']\\n\\nlen(vocabulary)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# remove possible diuplicate files with other extension names\\n!rm -rf .\\/photograph_template_texts\\/*\\n\\ntotal_images = 0\\nOK_images = 0\\nuncategorized_images = 0\\nfaulty_images = 0\\n\\nfilenames_file = open(\\\".\\/filenames_mapping.csv\\\",\\\"w\\\")\\nfilenames_file.write(\\\"Folder|Original|Commons\\\\n\\\")\\n\\nfor row_no, row in merged.iterrows():\\n # Filename: _GAR_.\\n outpath = \\\".\\/photograph_template_texts\\/\\\"\\n nome_foto = row[\\\"Nome_foto\\\"].replace(\\\" \\\", \\\"_\\\")\\n nome_foto_0, dummy, nome_foto_1 = nome_foto.rpartition(\\\"_\\\")\\n fname = str(nome_foto_0) + \\\"_-_\\\" + \\\"GAR\\\" + \\\"_-_\\\" + str(row[\\\"Folder\\\"]) + \\\"-\\\" + str(nome_foto_1) # + \\\".JPG\\\" Hack, extension ought to be dynamic\\n print(\\\"{}\\\".format(fname))\\n\\n filenames_file.write(\\\"{}|{}|{}\\\\n\\\".format(row[\\\"Folder\\\"],row[\\\"Nome_foto\\\"],fname))\\n \\n total_images += 1\\n \\n template_parts = []\\n \\n header = \\\"{{Photograph\\\"\\n template_parts.append(header)\\n \\n if not pd.isnull(row[\\\"Author\\\"]): \\n photographer = \\\"|photographer = \\\" + row[\\\"Author\\\"][4:]\\n else:\\n print(\\\"Warning! Empty Author column in row no {} photo {}\\\".format(row_no, row[\\\"Nome_foto\\\"]))\\n photographer = \\\"|photographer = \\\"\\n faulty_images += 1\\n template_parts.append(photographer)\\n \\n title_it = \\\"{{it|'''\\\" + regex.sub(\\\"_\\\",\\\" \\\",nome_foto_0) + \\\"'''}}\\\"\\n #title_en = \\\"{{en|\\\" + regex.sub(\\\"_\\\",\\\" \\\",row[\\\"Title\\\"][:-3]) + \\\"}}\\\"\\n \\n title = \\\"|title = \\\" + title_it #+ \\\"\\\\n\\\" + title_en\\n template_parts.append(title)\\n \\n if pd.notnull(row[\\\"Description\\\"]):\\n description_en = \\\"{{en|\\\" + row[\\\"Description\\\"] + \\\"}}\\\" # is empty though, not translated\\n else:\\n description_en = \\\"{{en|\\\" + str(row[\\\"Subject\\\"]) + \\\", \\\" + str(row[\\\"Place\\\"]) + \\\" in \\\" + str(row[\\\"Year\\\"]) + \\\"}}\\\"\\n \\n if pd.notnull(row[\\\"Descrizione\\\"]):\\n description_it = \\\"{{it|\\\" + row[\\\"Descrizione\\\"] + \\\"}}\\\"\\n else:\\n description_it = \\\"{{it|\\\" + str(row[\\\"Nome_monumento\\\"]) + \\\", \\\" + str(row[\\\"Luogo\\\"]) + \\\", \\\" + str(row[\\\"Anno\\\"]) + \\\"}}\\\"\\n \\n description = \\\"|description = \\\" +...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreate wikitext for image pages\\nAvailable as .py script on my github\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Compute the ratio of multi-label when query=(start, user).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndat_obj.traj_user['userID'].unique().shape\\n\\nquery_dict = dict()\\nfor tid in dat_obj.trajid_set_all:\\n t = dat_obj.traj_dict[tid]\\n if len(t) >= 2:\\n query = (t[0], dat_obj.traj_user.loc[tid, 'userID'])\\n try: query_dict[query].add(tid)\\n except: query_dict[query] = set({tid})\\n\\nmulti_label_queries = [q for q in query_dict.keys() if len(query_dict[q]) > 1]\\nprint('%d\\/%d ~ %.1f%%' % (len(multi_label_queries), len(query_dict), 100 * len(multi_label_queries) \\/ len(query_dict)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Notebooks\\/Word_Prediction_Quadgram_In_Constant_Time.ipynb\\\".\\nThe first task is:\\nDriver function for doing the prediction<\\/u>\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#returns: string\\n#arg: string,dict,int\\n#does prediction for the the sentence\\ndef doPrediction(sen,prob_dict,rank = 1):\\n if sen in prob_dict:\\n if rank <= len(prob_dict[sen]):\\n return prob_dict[sen][rank-1][1]\\n else:\\n return prob_dict[sen][0][1]\\n else:\\n return \\\"Can't predict\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Lab04\\/ML_lab4_ctr_student.ipynb\\\".\\nThe first task is:\\n(2c) Automated creation of an OHE dictionary \\nNow use the code from Parts (2a) and (2b) to write a function that takes an input dataset and outputs an OHE dictionary. Then use this function to create an OHE dictionary for the sample dataset, and verify that it matches the dictionary from Part (2b).\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# TODO: Replace with appropriate code\\ndef createOneHotDict(inputData):\\n \\\"\\\"\\\"Creates a one-hot-encoder dictionary based on the input data.\\n\\n Args:\\n inputData (RDD of lists of (int, str)): An RDD of observations where each observation is\\n made up of a list of (featureID, value) tuples.\\n\\n Returns:\\n dict: A dictionary where the keys are (featureID, value) tuples and map to values that are\\n unique integers.\\n \\\"\\\"\\\"\\n return (inputData.flatMap(lambda x : x).distinct().zipWithIndex().collectAsMap())\\n\\nsampleOHEDictAuto = createOneHotDict(sampleDataRDD)\\nprint sampleOHEDictAuto\\n\\n# TEST Automated creation of an OHE dictionary (2c)\\nTest.assertEquals(sorted(sampleOHEDictAuto.keys()),\\n [(0, 'bear'), (0, 'cat'), (0, 'mouse'), (1, 'black'),\\n (1, 'tabby'), (2, 'mouse'), (2, 'salmon')],\\n 'sampleOHEDictAuto has unexpected keys')\\nTest.assertEquals(sorted(sampleOHEDictAuto.values()), range(7),\\n 'sampleOHEDictAuto has unexpected values')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Lab1 Text processing with python.ipynb\\\".\\nThe first task is:\\nSo now we can create an instance of this class:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nstem_vectorizer = StemmedCountVectorizer(min_df=1,\\n stop_words='english')\\nstem_analyze = stem_vectorizer.build_analyzer()\\nY = stem_analyze(\\\"John bought carrots and potatoes\\\")\\n\\n[tok for tok in Y]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Choosing the Best Model\\n\\nBased on the experiments you performed earlier, in 1-2 paragraphs explain to the board of supervisors what single model you chose as the best model. Which model is generally the most appropriate based on the available data, limited resources, cost, and performance?\\nIn 1-2 paragraphs explain to the board of supervisors in layman's terms how the final model chosen is supposed to work (for example if you chose a Decision Tree or Support Vector Machine, how does it make a prediction).\\nFine-tune the model. Use Gridsearch with at least one important parameter tuned and with at least 3 settings. Use the entire training set for this.\\nWhat is the model's final F_{1<\\/sub> score?\\n\\nComparing Models\\n\\nTraining time: AdaBoost > SVM > Decision Tree\\nPredicting time: AdaBoost > SVM > Decision Tree\\nF1 score for test set on size of 300: AdaBoost > SVM > Decision Tree\\n\\nI would like to choose Adaboost for this case, because\\n1. The Fl scose of this model is the best based on the above results.\\n2. The training time could be acceptable, although it's highest in these three models.\\n3. Because our goal is to model the factors that predict how likely a student is to pass their high school final exam and take some intervention in advanced, we do have time to compute the result. So we should focus on the F1 score instead of computational cost. \\nHow AdaBoost works\\n\\nAdaBoost is a type of \\\"Ensemble Learning\\\" where multiple classifiers are employed to build a stronger learning algorithm. AdaBoost works by choosing a base classifier (e.g. decision trees) and iteratively improving it by accounting for the incorrectly classified examples in the training set. \\nTraining :\\nFirst, we assign equal weights to all the training examples and choose a base classifier (e.g. decision trees). We can think of each weight as an importance weight that tells us how important the example is for our current learning task\\nSecondly, we apply the base classifier (e.g. decision trees) to the training set and increase the weights of the...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.grid_search import GridSearchCV\\nfrom sklearn.metrics import f1_score\\nfrom sklearn.metrics import make_scorer\\nfrom sklearn.cross_validation import StratifiedShuffleSplit\\n\\nparam_grid = {\\\"n_estimators\\\": np.arange(3,20,2), \\\"learning_rate\\\": np.arange(0.5,0.8,0.02)}\\nscoring_function = make_scorer(f1_score, pos_label='yes', average='binary')\\n\\nclf = GridSearchCV(AdaBoostClassifier(), param_grid=param_grid, scoring=scoring_function)\\nclf.fit(X_train, y_train)\\ntraining_score,_ = predict_labels(clf.best_estimator_, X_train, y_train)\\ntesting_score,_ = predict_labels(clf.best_estimator_, X_test, y_test)\\nprint \\\"Best parameters: {}\\\".format(clf.best_params_)\\nprint \\\"F1 score for training set: {}\\\".format(training_score)\\nprint \\\"F1 score for test set: {}\\\".format(testing_score)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Ahora sí podemos ver el resultado final en ambos casos:\\n\",\"targets\":\"subplot(1,2,1)\\nplt.imshow(s.result[:,:,s.max_iter-1])\\nsubplot(1,2,2)\\nplt.imshow(random_diff[:,:,s.max_iter-1])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Old_Runs\\/tutorial_6slices.ipynb\\\".\\nThe first task is:\\nLet's see what our chains look like by producing trace plots:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#set up subplots for chain plotting\\naxes=['ax'+str(i) for i in range(ndim)]\\nfig, (axes) = plt.subplots(ndim, figsize=(10,60))\\n\\nplt.tight_layout()\\n\\nfor i in range(0,ndim):\\n if i b\\n\\n#smaller or equal\\na <= b\\n\\n#equality\\na == b\\n\\n#inequality \\na != b\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Create grid specifying to use years for columns and stats for rows\\ngrid = sns.FacetGrid(yearly_msgs, col='year', row='stat', margin_titles=True, sharey=True, legend_out=True)\\n# Map to each grid sub-plot a barplot\\ngrid.map(sns.barplot, 'month', 'val', 'sender')\\ngrid.axes[0][0].legend()\\nsns.plt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFacet Grid\\nThis format doesn't follow the tidy data guidelines, but can be useful for quick playing around and plotting, especially when using Seaborn FacetGrid. We compose our plot specifying how subplots are built in terms of rows and columns, for then applying to each a basic plotting function.\\nIn the following example each column is a year, and different rows are different statistics about our messages. Each plot will then show the values along months, for each sender. Even if this explanation sounds convoluted, the actual plot is really intuitive and helpful when visualizing such kind of data. \\nThe sharing of axis (keep the same scale for the plots) is also an important part of the grid, that can help visualize how your values vary among different plots. At the same time some sharing might just be counterproductive, for example when comparing values with a big scale or range difference. We have one of such cases when comparing text_len with the other stats.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"02_PyomoOverview.ipynb\\\".\\nThe first task is:\\nNote:\\nIn Python, indexes are in square brackets and function arguments are in parentheses.\\n\\nIn order to declare constraints that use this expression, we use the Pyomo Constraint<\\/span> function that takes a variety of arguments. In this case, our model specifies that we can have more than one constraint of the same form and we have created a set, model.I<\\/span>, over which these constraints can be indexed so that is the first argument to the constraint declaration function. The next argument gives the rule that will be used to generate expressions for the constraints. Taken as a whole, this constraint declaration says that a list of constraints indexed by the set model.I<\\/span> will be created and for each member of model.I, the function ax_constraint_rule<\\/span> will be called and it will be passed the model object as well as the member of model.I<\\/span>.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# the next line creates one constraint for each member of the set model.I\\nmodel.AxbConstraint = Constraint(model.I, rule=ax_constraint_rule)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2. Conditions: if statements\\nYou might wonder why we took quite some time explaining boolean expresisons. One of the reasons is that they are the main element in probably one of the most used things in Python: if statements. The following picture explains what happens in an if statement in Python.\\n\\nLet's look at an example (modify the value of number to understand what is happening here):\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnumber = 2 # try changing this value to 6\\nif number <= 5:\\n print(number)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# number of passes is number to complete the whole dataset\\n# For each batch size, we update 1 gradient, so\\n\\n2*(50000\\/100)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nQuiz Question. When you set batch_size = len(train_data), as each iteration passes, how does the average log likelihood in the batch change?\\n* Increases \\n* Decreases\\n* Fluctuates \\nMake \\\"passes\\\" over the dataset\\nTo make a fair comparison betweeen stochastic gradient ascent and batch gradient ascent, we measure the average log likelihood as a function of the number of passes (defined as follows):\\n$$\\n[\\\\text{# of passes}] = \\\\frac{[\\\\text{# of data points touched so far}]}{[\\\\text{size of dataset}]}\\n$$\\nQuiz Question Suppose that we run stochastic gradient ascent with a batch size of 100. How many gradient updates are performed at the end of two passes over a dataset consisting of 50000 data points?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%load_ext rpy2.ipython\\n\\n%%R -h 800 -w 800\\nlibrary(ape)\\ntre <- read.tree(\\\"empirical_10\\/RAxML_bipartitions.empirical_10_m4\\\")\\nltre <- ladderize(tre)\\n\\npar(mfrow=c(1,2))\\nplot(ltre, use.edge.length=F)\\nnodelabels(ltre$node.label)\\n\\nplot(ltre, type='u')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPlot the tree in R using ape\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create a target variable\\nThe original task in Kaggle's}PetFinder.my Adoption Prediction competition<\\/a> was to predict the speed at which a pet will be adopted (e.g. in the first week, the first month, the first three months, and so on).\\nIn this tutorial, you will simplify the task by transforming it into a binary classification problem, where you simply have to predict whether a pet was adopted or not.\\nAfter modifying the AdoptionSpeed column, 0 will indicate the pet was not adopted, and 1 will indicate it was.\\n\",\"targets\":\"# In the original dataset, `'AdoptionSpeed'` of `4` indicates\\n# a pet was not adopted.\\ndataframe['target'] = np.where(dataframe['AdoptionSpeed']==4, 0, 1)\\n\\n# Drop unused features.\\ndataframe = dataframe.drop(columns=['AdoptionSpeed', 'Description'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Aeon configuration\\nAeon allows a diverse set of configurations to specify which transformations are applied on-the-fly during training. These configs are specific as python dictionaries. For more detail, see the aeon documentation.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nconfig = {\\n 'manifest_filename': 'data\\/cifar10\\/train-index.csv', # CSV manifest of data\\n 'manifest_root': 'data\\/cifar10', # root data directory\\n 'image': {'height': 224, 'width': 224, # output image size \\n 'scale': [0.875, 0.875], # random scaling of image before cropping\\n 'flip_enable': True}, # randomly flip image\\n 'type': 'image,label', # type of data\\n 'minibatch_size': be.bsz # batch size\\n}\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Building the network\\nTFLearn lets you build the network by defining the layers in that network. \\nFor this example, you'll define:\\n\\nThe input layer, which tells the network the number of inputs it should expect for each piece of MNIST data. \\nHidden layers, which recognize patterns in data and connect the input to the output layer, and\\nThe output layer, which defines how the network learns and outputs a label for a given image.\\n\\nLet's start with the input layer; to define the input layer, you'll define the type of data that the network expects. For example,\\nnet = tflearn.input_data([None, 100])\\nwould create a network with 100 inputs. The number of inputs to your network needs to match the size of your data. For this example, we're using 784 element long vectors to encode our input data, so we need 784 input units.\\nAdding layers\\nTo add new hidden layers, you use \\nnet = tflearn.fully_connected(net, n_units, activation='ReLU')\\nThis adds a fully connected layer where every unit (or node) in the previous layer is connected to every unit in this layer. The first argument net is the network you created in the tflearn.input_data call, it designates the input to the hidden layer. You can set the number of units in the layer with n_units, and set the activation function with the activation keyword. You can keep adding layers to your network by repeated calling tflearn.fully_connected(net, n_units). \\nThen, to set how you train the network, use:\\nnet = tflearn.regression(net, optimizer='sgd', learning_rate=0.1, loss='categorical_crossentropy')\\nAgain, this is passing in the network you've been building. The keywords: \\n\\noptimizer sets the training method, here stochastic gradient descent\\nlearning_rate is the learning rate\\nloss determines how the network error is calculated. In this example, with categorical cross-entropy.\\n\\nFinally, you put all this together to create the model with tflearn.DNN(net).\\nExercise: Below in the build_model() function, you'll put together the network using TFLearn. You get to choose how many layers...\\n\",\"targets\":\"# Define the neural network\\ndef build_model():\\n # This resets all parameters and variables, leave this here\\n tf.reset_default_graph()\\n \\n #### Your code ####\\n # Include the input layer, hidden layer(s), and set how you want to train the model\\n net = tflearn.input_data([None, 784])\\n net = tflearn.fully_connected(net, n_units=200, activation='ReLU')\\n net = tflearn.fully_connected(net, n_units=30, activation='ReLU')\\n net = tflearn.fully_connected(net, n_units=10, activation='softmax')\\n net = tflearn.regression(net, optimizer='sgd', learning_rate=0.1, loss='categorical_crossentropy')\\n \\n \\n # This model assumes that your network is named \\\"net\\\" \\n model = tflearn.DNN(net)\\n return model\\n\\n# Build the model\\nmodel = build_model()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A basic issue here is scaling and efficiency. A single input to our model is a vector of 165,237 numbers (of which we know that 165,235 will be zeros). The feature data for our whole dataset of 20 million rating instances will require a 2-d array of size 20,000,000 x 165,237, or about 3 trillion numbers. Good luck fitting that all into memory at once!\\nAlso, doing training and inference on our model will be inefficient. To calculate the activations of our first hidden layer, we'll need to multiply our 165k inputs through about 21 million weights - but the vast, vast majority of those products will just be zero.\\nOne-hot encoding is fine for categorical variables with a small number of possible values, like {Red, Yellow, Green}, or {Monday, Tuesday, Wednesday, Friday, Saturday, Sunday}. But it's not so great in cases like our movie recommendation problem, where variables have tens or hundreds of thousands of possible values.\\nGood idea: Embedding layers\\nIn short, an embedding layer maps each element in a set of discrete things (like words, users, or movies) to a dense vector of real numbers (its embedding). \\n\\nAside: A key implementation detail is that embedding layers take as input the index of the entity being embedded (i.e. we can give it our userIds and movieIds as input). You can think of it as a sort of 'lookup table'. This is much more efficient than taking a one-hot vector and doing a huge matrix multiplication!\\n\\nAs an example, if we learn embeddings of size 8 for movies, the embedding for Legally Blonde (index=4352) might look like:\\n$$[ 1.624, -0.612, -0.528, -1.073, 0.865, -2.302, 1.745, -0.761]$$\\nWhere do these come from? We initialize an embedding for each user and movie using random noise, then we train them as part of the process of training the overall rating-prediction model. \\nWhat do they mean? An object's embedding, if it's any good, should capture some useful latent properties of that object. But the key word here is latent AKA hidden. It's up to the model to discover whatever properties of...\\n\",\"targets\":\"hidden_units = (32,4)\\nmovie_embedding_size = 8\\nuser_embedding_size = 8\\n\\n# Each instance will consist of two inputs: a single user id, and a single movie id\\nuser_id_input = keras.Input(shape=(1,), name='user_id')\\nmovie_id_input = keras.Input(shape=(1,), name='movie_id')\\nuser_embedded = keras.layers.Embedding(df.userId.max()+1, user_embedding_size, \\n input_length=1, name='user_embedding')(user_id_input)\\nmovie_embedded = keras.layers.Embedding(df.movieId.max()+1, movie_embedding_size, \\n input_length=1, name='movie_embedding')(movie_id_input)\\n# Concatenate the embeddings (and remove the useless extra dimension)\\nconcatenated = keras.layers.Concatenate()([user_embedded, movie_embedded])\\nout = keras.layers.Flatten()(concatenated)\\n\\n# Add one or more hidden layers\\nfor n_hidden in hidden_units:\\n out = keras.layers.Dense(n_hidden, activation='relu')(out)\\n\\n# A single output: our predicted rating\\nout = keras.layers.Dense(1, activation='linear', name='prediction')(out)\\n\\nmodel = keras.Model(\\n inputs = [user_id_input, movie_id_input],\\n outputs = out,\\n)\\nmodel.summary(line_length=88)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#Splitte Daten in Trainings und Test Daten unter Einhaltung der Klassen Ratio\\nstratiefied_splitter = StratifiedShuffleSplit(n_splits=1,test_size=0.2,random_state=42)\\nfor train_index,test_index in stratiefied_splitter.split(data,binary_target):\\n training_data = data[train_index,:]\\n training_target = binary_target[train_index]\\n testing_data = data[test_index,:]\\n testing_target = binary_target[test_index]\\n\\nprint(\\\"Trainingsdaten\\\")\\nprint(\\\"Anzahl Patienten:\\\\t\\\\t%d\\\"%training_data.shape[0])\\nprint(\\\"Anzahl Features:\\\\t\\\\t%d\\\"%training_data.shape[1])\\nprint(\\\"Anzahl Patienten Klasse 0:\\\\t%d\\\"%(training_target==0).sum())\\nprint(\\\"Anzahl Patienten Klasse 1:\\\\t%d\\\"%(training_target==1).sum())\\nprint\\nprint(\\\"Testdaten\\\")\\nprint(\\\"Anzahl Patienten:\\\\t\\\\t%d\\\"%testing_data.shape[0])\\nprint(\\\"Anzahl Features:\\\\t\\\\t%d\\\"%testing_data.shape[1])\\nprint(\\\"Anzahl Patienten Klasse 0:\\\\t%d\\\"%(testing_target==0).sum())\\nprint(\\\"Anzahl Patienten Klasse 1:\\\\t%d\\\"%(testing_target==1).sum())\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n \\n \\nEine 5-fache Kreuzvalidierung auf den Trainingsdaten führt zu einem Mean Squared Error von $MSE=587.09 \\\\pm 53.54$. Auf den Testdaten erhalten wir einen Fehler von $MSE=699.56$ ($\\\\sim 26.5$ Tage). Das bedeutet, dass das Ridge Regression Modell zu eher schlechten Vorhersagen führt (trotz Parameteroptimierung). \\nDas kann z. B. daran liegen, dass die vorhandenen Features die genaue Zielvariable (Anzahl der Tage bis das Medikament wirkt) nur unzureichend beschreibt. \\n<\\/div>\\n \\n\\nWegen der eher entäuschenden Ergebnisse besprechen sich unsere Auftragsgeber nochmals. Nach längerer Beratung erklären uns diese, dass es ihnen eigentlich nicht auf die genaue Anzahl der Tage ankomme. Vielmehr würde ihnen ausreichen, wenn wir die Patienten vorhersagen könnten, welche eine längere bzw. eine kürzere Reaktionszeit haben. \\nLaut den Erfahrungen unseres Auftraggebers ist ab circa 50 Tagen Anwendung mit erheblichen Nebenwirkungen zu rechen. Wir binarisieren unsere Daten, indem alle Patienten mit bis zu 50 Tagen in Klasse 0 und alle Patienten mit mehr als 50 Tagen in Klasse 1 aufgeteilt werden. \\nSomit können wir statt einer Regression einen Klassifikationsalgorithmus verwenden, welcher versucht, die Patienten in diese zwei unterschiedlichen Klassen zu klassifizieren.\\n<\\/div>\\n2. Vorhersage von Patienten mit Langsamer vs. Schneller Reaktionszeit mit einer Support-Vector-Machine\\n2.1 Daten Vorverarbeitung\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Homework\\/Principles of Artificial Neural Networks\\/Week 10 GAN 2\\/DL_WEEK10.ipynb\\\".\\nThe first task is:\\n生成网络G,一个Encoder-Decoder模型，借鉴了U-Net结构，所谓的U-Net是将第i层拼接到第n-i层，这样做是因为第i层和第n-i层的图像大小是一致的。\\n判别网络D,Pix2Pix中的D被实现为Patch-D，所谓Patch，是指无论生成的图像有多大，将其切分为多个固定大小的Patch输入进D去判断。\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport torch.nn as nn\\nimport torch.nn.functional as F\\nimport torch\\n\\n\\n##############################\\n# U-NET\\n##############################\\n\\n\\nclass UNetDown(nn.Module):\\n def __init__(self, in_size, out_size, normalize=True, dropout=0.0):\\n super(UNetDown, self).__init__()\\n layers = [nn.Conv2d(in_size, out_size, 4, 2, 1, bias=False)]\\n if normalize:\\n # when baych-size is 1, BN is replaced by instance normalization\\n layers.append(nn.InstanceNorm2d(out_size))\\n layers.append(nn.LeakyReLU(0.2))\\n if dropout:\\n layers.append(nn.Dropout(dropout))\\n self.model = nn.Sequential(*layers)\\n\\n def forward(self, x):\\n return self.model(x)\\n\\n\\nclass UNetUp(nn.Module):\\n def __init__(self, in_size, out_size, dropout=0.0):\\n super(UNetUp, self).__init__()\\n layers = [\\n nn.ConvTranspose2d(in_size, out_size, 4, 2, 1, bias=False),\\n # when baych-size is 1, BN is replaced by instance normalization\\n nn.InstanceNorm2d(out_size),\\n nn.ReLU(inplace=True),\\n ]\\n if dropout:\\n layers.append(nn.Dropout(dropout))\\n\\n self.model = nn.Sequential(*layers)\\n\\n def forward(self, x, skip_input):\\n x = self.model(x)\\n x = torch.cat((x, skip_input), 1)\\n\\n return x\\n\\n\\nclass GeneratorUNet(nn.Module):\\n def __init__(self, in_channels=3, out_channels=3):\\n super(GeneratorUNet, self).__init__()\\n\\n self.down1 = UNetDown(in_channels, 64, normalize=False)\\n self.down2 = UNetDown(64, 128)\\n self.down3 = UNetDown(128, 256)\\n self.down4 = UNetDown(256, 256, dropout=0.5)\\n self.down5 = UNetDown(256, 256, dropout=0.5)\\n self.down6 = UNetDown(256, 256, normalize=False, dropout=0.5)\\n\\n self.up1 = UNetUp(256, 256, dropout=0.5)\\n self.up2 = UNetUp(512, 256)\\n self.up3 = UNetUp(512, 256)\\n self.up4 = UNetUp(512, 128)\\n self.up5 = UNetUp(256, 64)\\n\\n self.final = nn.Sequential(\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"<\\/a>\\n2.2 Writing tables to Civis\\nNow that we have our modified data, let's put it back into your Redshift cluster. Use the function civis.io.dataframe_to_civis to do the upload. We'll put it into a table in the \\\"scratch\\\" schema. That's a customary location for tables we don't intend to keep around for long.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nrbm_tablename = 'scratch.rides_by_month'\\nfut = civis.io.dataframe_to_civis(\\n df=rides_by_month,\\n database=DATABASE,\\n table=rbm_tablename,\\n distkey='month',\\n sortkey1='month',\\n existing_table_rows='drop',\\n) # This is non-blocking\\nprint(fut)\\n\\nfut.result() # This blocks (warning: can take a few minutes to run)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Run CG\\ninit = tf.initialize_all_variables()\\nsess = tf.Session()\\nsess.run(init)\\nh0 = np.zeros([batch_size,H], dtype=float)\\nindices = collections.deque()\\ncosts = 0.0; epoch_iters = 0\\nfor n in range(50):\\n \\n # Batch extraction\\n if len(indices) < 1:\\n indices.extend(range(epoch_size))\\n costs = 0.0; epoch_iters = 0\\n i = indices.popleft() \\n batch_x = train_data[:,i*T:(i+1)*T]\\n batch_x = convert_to_one_hot(batch_x,D);\\n #print(batch_x)\\n batch_x = np.reshape(batch_x,[batch_size,T,D])\\n batch_y = train_data[:,i*T+1:(i+1)*T+1]\\n #print(batch_x.shape,batch_y.shape)\\n idx = char_to_ix['h'];\\n print(idx)\\n loss_value,_,Ypredicted = sess.run([loss,train_step,Ypred], feed_dict={xin: batch_x, Ytarget: batch_y, hin: h0, idx_pred: [idx]}) \\n \\n # Perplexity\\n costs += loss_value\\n epoch_iters += T\\n perplexity = np.exp(costs\\/epoch_iters)\\n \\n #ix = 0;\\n if not n%1:\\n idx_char = Ypredicted\\n #print(idx_char)\\n txt = ''.join(ix_to_char[ix] for ix in list(idx_char[:,0]))\\n print('\\\\nn=',n,', perplexity value=',perplexity)\\n print('starting char=',ix_to_char[idx], ', predicted sequences=',txt)\\n \\nsess.close()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nStep 7\\nRun the computational graph with batches of training data. \\nPredict the sequence of characters starting from the character \\\"h\\\". \\nHints: \\n(1) Initial memory is $h_{t=0}$ is 0. \\n(2) Run the computational graph to optimize the perplexity loss, and to predict the the sequence of characters starting from the character \\\"h\\\". \",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#%%cypher\\nres = %cypher MATCH q=(r)-[:ANSWERS]->(p) RETURN p.Id,r.Id;\\ndf = res.get_dataframe()\\ndf['r.Id'] = pd.to_numeric(df['r.Id'],downcast='unsigned')\\ndf['p.Id'] = pd.to_numeric(df['p.Id'],downcast='unsigned')\\n\\ndf.plot(kind='scatter',x='p.Id',y='r.Id',figsize=(15,15))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLas construcciones %cypher retornan resultados de los que se puede obtener un dataframe de pandas:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"16_Reinforcement_Learning.ipynb\\\".\\nThe first task is:\\nExample: Highest Q-Value\\nThis example shows the states surrounding the one with the highest Q-values. This means that the agent has high expectation that several points will be scored in the following steps. Note that the Q-values decrease significantly after the points have been scored.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nidx = np.argmax(q_values_max)\\nidx\\n\\nfor i in range(0, 5):\\n plot_state(idx=idx+i)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3) Now describe your pre-processed data for training and validation: numer of training and validation images, number of classes, class names? Do the images have the same size? (1 pts)\\nYour response:\\n4) Redefine, train and validate the 2 CNNs in Part I (namely modelPart2_cnn1, modelPart2_cnn2) on the new data using model.fit_generator instead of model.fit. Observe and compare the results. (3 pts)\\n\",\"targets\":\"# Define the model \\n# modelPart2_cnn1 = Sequential() \\n\\n\\n\\n# train with .fit_generator\\n# modelPart2_cnn1.fit_generator(...)\\n\\n\\n# Define the model \\n# modelPart2_cnn2 = Sequential() \\n\\n\\n# train with .fit_generator\\n# modelPart2_cnn2.fit_generator(...)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Controlling for Random Negatve vs Sans Random in Imbalanced Techniques using S, T, and Y Phosphorylation.\\nIncluded is N Phosphorylation however no benchmarks are available, yet. \\nTraining data is from phospho.elm and benchmarks are from dbptm. \\nNote: SMOTEEN seems to preform best\\n\",\"targets\":\"par = [\\\"pass\\\", \\\"ADASYN\\\", \\\"SMOTEENN\\\", \\\"random_under_sample\\\", \\\"ncl\\\", \\\"near_miss\\\"]\\nfor i in par:\\n print(\\\"y\\\", i)\\n y = Predictor()\\n y.load_data(file=\\\"Data\\/Training\\/clean_s_filtered.csv\\\")\\n y.process_data(vector_function=\\\"sequence\\\", amino_acid=\\\"S\\\", imbalance_function=i, random_data=0)\\n y.supervised_training(\\\"bagging\\\")\\n y.benchmark(\\\"Data\\/Benchmarks\\/phos_stripped.csv\\\", \\\"S\\\")\\n del y\\n print(\\\"x\\\", i)\\n x = Predictor()\\n x.load_data(file=\\\"Data\\/Training\\/clean_s_filtered.csv\\\")\\n x.process_data(vector_function=\\\"sequence\\\", amino_acid=\\\"S\\\", imbalance_function=i, random_data=1)\\n x.supervised_training(\\\"bagging\\\")\\n x.benchmark(\\\"Data\\/Benchmarks\\/phos_stripped.csv\\\", \\\"S\\\")\\n del x\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"3-seq2seq-native-new.ipynb\\\".\\nThe first task is:\\nBy this point implementations are quite long, so I put them in model_new.py, while notebook will illustrate the application.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntf.reset_default_graph()\\ntf.set_random_seed(1)\\n\\nwith tf.Session() as session:\\n\\n # with bidirectional encoder, decoder state size should be\\n # 2x encoder state size\\n model = Seq2SeqModel(encoder_cell=LSTMCell(10),\\n decoder_cell=LSTMCell(20), \\n vocab_size=10,\\n embedding_size=10,\\n attention=True,\\n bidirectional=True,\\n debug=False)\\n\\n session.run(tf.global_variables_initializer())\\n\\n train_on_copy_task(session, model,\\n length_from=3, length_to=8,\\n vocab_lower=2, vocab_upper=10,\\n batch_size=100,\\n max_batches=3000,\\n batches_in_epoch=1000,\\n verbose=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"##KK: currently running a GridSearchCV, but this is the best classifier so far\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nParameters\\/Results:\\n\\nStarting Parameters:\\nLogisticRegression: penalty='l2', solver='newton-cg', C=500, tol=0.01\\nAdaBoostClassifier: default\\nOptimized Parameters:\\nN\\/A\\nResult:\\nMulti-class Log Loss: 3.58335097496\\n\\nBagging Classifier\\nHyperparameter tuning:\\nFor the Bagging meta classifier, we can seek to optimize the following classifier parameters: n_estimators (the number of trees in the forsest), max_samples, max_features, bootstrap (whether or not bootstrap samples are used when building trees), bootstrap_features (whether features are drawn with replacement), and oob_score (whether or not out-of-bag samples are used to estimate the generalization accuracy)\\nBagging each classifier:\\nWe will run the BaggingClassifier on each different classifier from above, using the classifier settings with optimized Multi-class Log Loss after hyperparameter tuning and calibration.\\nGradient Boosting Classifier\\nHyperparameter tuning:\\nFor the Gradient Boosting meta classifier, we can seek to optimize the following classifier parameters: n_estimators (the number of trees in the forsest), max_depth, min_samples_leaf, and max_features\\nGradient Boosting each classifier:\\nWe will run the GradientBoostingClassifier with loss = 'deviance' (as loss = 'exponential' uses the AdaBoost algorithm) on each different classifier from above, using the classifier settings with optimized Multi-class Log Loss after hyperparameter tuning and calibration.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Practicas\\/.ipynb_checkpoints\\/Practica 3 - Visualizacion de sistemas mecanicos-checkpoint.ipynb\\\".\\nThe first task is:\\nPor ultimo, para animar esto, tenemos que obtener los puntos de la trayectoria:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nm = 1200\\nc = 1500\\nk = 15000\\nF = 4000\\n\\nG = tf([0, 0, 1\\/m], [1, c\\/m, k\\/m])\\nK = tf([F], [1])\\nt = linspace(0, 10, 1000)\\n\\ny, t = step(K*G, t)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Búsqueda en una Serie\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndeportes = {'Capoeira': 'Brasil',\\n 'Rayuela': 'Chile',\\n 'Pelota Vasca': 'País Vasco',\\n 'Béisbol': 'Cuba',\\n 'Rugby': 'Gales',\\n 'Golf': 'Escocia',\\n 'Corrida de Toros': 'España',\\n 'Sumo': 'Japón'}\\ns = pd.Series(deportes)\\ns\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Building & Selecting the SARIMA Model\\nNote That, I kept the last two years out of the trainnig process for the testing phase\\n\",\"targets\":\"# air_data = air_data.set_index('time')\\nmod = sm.tsa.statespace.SARIMAX(air_data['AirPassengers'][1:120], order=(0,0,0), seasonal_order=(3,2,0,12))\\nresults = mod.fit()\\nprint results.summary()\\n\\nresults.plot_diagnostics(figsize=(16, 12));\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Defining functions to compute ngram frequency\\ndef word_counter(text, n=1, length_thres=50):\\n t = text.split()\\n t = [tk for tk in t if len(tk) < length_thres]\\n for i in range(n):\\n t_ngrams = [\\\" \\\".join(b) for b in list(ngrams(t, i + 1))]\\n t.extend(t_ngrams)\\n return Counter(t)\\n\\ndef word_aggregater(corpus_list, n=1):\\n c = Counter()\\n for doc in corpus_list:\\n c.update(word_counter(doc, n=n))\\n return c\\n\\ndef count_token_frequency(token_series, filter_thres, **kwargs):\\n freq_df = pd.DataFrame(word_aggregater(token_series, **kwargs).items())\\n freq_df.rename(columns={0: 'word', 1: 'frequency'}, inplace=True)\\n freq_df = freq_df[freq_df['frequency'] > filter_thres] \\\\\\n .sort_values('frequency', ascending=False)\\n freq_df['ngrams'] = freq_df['word'].apply(lambda x: len(x.split()))\\n return freq_df.reset_index(drop=True)\\n\\n# create frequency count dataframes\\nsecrets_corpus = count_token_frequency(match_secrets['clean_tokens_secret'], 0, n=3)\\nsecrets_not_reported_corpus = count_token_frequency(match_not_reported['clean_tokens_secret'], 0, n=3)\\nsecrets_reported_corpus = count_token_frequency(match_reported['clean_tokens_secret'], 0, n=3)\\nreport_text_corpus = count_token_frequency(report_text['clean_tokens_secret'], 0, n=3)\\n\\n# merge frequencies for all secrets, reported, and not reported\\nmerge_cols = ['word', 'frequency']\\nall_corpus = secrets_corpus.merge(secrets_not_reported_corpus[merge_cols], on=\\\"word\\\", \\n how=\\\"left\\\", suffixes=(\\\"_all\\\", \\\"_not_reported\\\"))\\nall_corpus = all_corpus.merge(secrets_reported_corpus[merge_cols], on=\\\"word\\\", how=\\\"left\\\")\\nall_corpus = all_corpus.rename(columns={'frequency': 'frequency_reported'})\\nall_corpus.head()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAs you can see, the n-word is one of the most frequently used words in the dataset, along with a smattering of expletives and some other pretty mundane verbiage. I don't know about you, but when I first saw this word cloud I thought to myself: \\\"wow, this platform enables racism and bigotry because anonymity\\\".\\nPardon the grammitically incorrect thought, but actually I think I may have been jumping to a conclusion there. Isn't the entire internet a platform for trolling, bigotry, and racism? It occured to me that the quality of content on a social media platform is heavily influenced by the moderation system of that platform.\\nLike Facebook and Twitter, Confesh has a moderation system that communities can use to report confessions and comments. We will end this post by answering a final question: \\n\\nIf we group confessions by those that were reported by the community and those that were not, how would the above word frequency distribution change? \\n\\nCounting Ngrams: An Introduction to Text-mining\\nIt's great to count individual words and all, but what we lose by doing that is context. \\nWhat words appeared together in sequence? \\nA simple way to address this problem is by computing ngrams. An ngram is the n sequence of words that appear in succession for any given piece of text. So a unigram would be a single word, a bigram would be a sequence of two words, like so:\\n\\nUnigram (1-gram): 'the'\\nBigram (2-gram): 'the cat'\\nTrigram (3-gram): 'the cat sits\\n...\\n\\nDoing this allows us to at least capture the most frequent sequences of words.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"(1) The callback rate for each group (black-sounding and white-sounding names) follows a binomial distribution, which approaches a normal distribution when np>10 and n(1-p)>10 (see below). Therefore, the difference in call back rate follows a normal distribution, and the CLT can be applied.\\n\",\"targets\":\"n_b = data[data.race=='b'].call.count() #total number of black-sounding names\\np_b = np.sum(data[data.race=='b'].call)\\/n_b #callback rate for black-sounding names\\nn_w = data[data.race=='w'].call.count() #total number of white-sounding names\\np_w = np.sum(data[data.race=='w'].call)\\/n_w #callback rate for white-sounding names \\nprint('np for black-sounding names: ' + str(n_b * p_b))\\nprint('n(1-p) for black-sounding names: ' + str(n_b * (1-p_b))) \\nprint('np for white-sounding names: ' + str(n_w * p_w))\\nprint('n(1-p) for white-sounding names: ' + str(n_w * (1-p_w)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\n או:\\n<\\/p>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npreformatted_message = \\\"My name is {me}, and my sister is {sister}\\\"\\nparameters = {'me': 'Mei', 'sister': 'Satsuki'}\\nmessage = preformatted_message.format(**parameters)\\nprint(message)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Compute counterfactual predictions\\nOur chains look stationary, well-mixing and similar to one another. This signals that our sampler probably did its job. Furthermore, the point estimates computed by the baseline model are contained in our posteriors. As the focus of this work is the overall analysis of the graphical model and not on these specific parameter estimates themselves, I don't dig further.\\nThe next task is to compute counterfactual predictions for $P(\\\\text{Traffic}\\\\ |\\\\ \\\\text{President}, \\\\text{Accident})$, i.e. \\\"given some inputs for $P$ and $A$ in our model, what's the probability of observing traffic?\\\" Remember, our model looks as follows:\\n$$\\n\\\\text{traffic} \\\\sim \\\\text{Binomial}(1, p)\\\\\\n\\\\log\\\\bigg(\\\\frac{p}{1 - p}\\\\bigg) = \\\\alpha + \\\\beta_P P + \\\\beta_A A\\n$$\\nWhat values do we use for $\\\\alpha, \\\\beta_P, \\\\beta_A$, you ask? Well, we've got a whole bunch of choices in the cell above.\\nAs such, we'll take the trace for each variable - the values returned by the sampler, i.e. the squiggly plot on the right, from which we build the empirical distribution on the left - and plug in some new values for $P$ and $A$. The sampler used 4 chains of 2000 samples each, so we now have 8000 tuples of $(\\\\alpha, \\\\beta_P, \\\\beta_A)$. Our new values for $P$ and $A$ can be whatever we want. (In fact, they don't even have to have been observed in our data to begin with!)\\nFirst, we'll take the tuple $(P = 0, A = 0)$. We'll then plug this into our regression equation for each of the 8000 tuples of $(\\\\alpha, \\\\beta_P, \\\\beta_A)$. Solving for $p$, this will give us 8000 values for $P(\\\\text{Traffic} = 1\\\\ |\\\\ \\\\text{President} = 0, \\\\text{Accident} = 0)$. We then repeat for $(P = 0, A = 1), (P = 1, A = 0)$ and $(P = 1, A = 1)$.\\n\",\"targets\":\"def sigmoid(z):\\n return 1 \\/ (1 + np.exp(-z))\\n\\ndef compute_counterfactual_predictions(president_value, accident_value, trace=trace):\\n log_odds_p = trace['Intercept'] + trace['president']*president_value + trace['accident']*accident_value\\n return sigmoid(log_odds_p)\\n\\ndef compute_prediction_interval(predictions, percentile=94):\\n lower_percentile_bound = (100 - percentile) \\/ 2\\n upper_percentile_bound = 100 - lower_percentile_bound\\n return np.percentile(predictions, lower_percentile_bound), np.percentile(predictions, upper_percentile_bound)\\n\\ninput_combinations = [(0, 0), (0, 1), (1, 0), (1, 1)]\\ncounterfactual_predictions = {}\\nobserved_proportions = {}\\n\\nfor p, a in input_combinations:\\n counterfactual_predictions[JointInput(p=p, a=a)] = compute_counterfactual_predictions(p, a)\\n observed_proportions[JointInput(p=p, a=a)] = \\\\\\n observed_data[(observed_data['president'] == p) & (observed_data['accident'] == a)]['traffic'].mean()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"C\\nWrite a function, is_palindrome, which determines whether or not a list is a palindrome.\\n\\ninput: 1 argument, a list\\noutput: a boolean, True if the input list is a palindrome, False otherwise\\n\\nRecall a palindrome is typically a word or sequence of words that reads identically forwards as backwards.\\nFor example, is_palindrome([1, 2, 1]) would return True, but is_palindrome([1, 1, 2, 1]) would return False.\\nYou cannot use any built-in or imported functions.\\n\",\"targets\":\"i1 = [1, 2, 1]\\nassert is_palindrome(i1)\\n\\ni2 = [1, 1, 2, 1]\\nassert not is_palindrome(i2)\\n\\ni3 = [1, 2, 3, 4, 5, 4, 3, 2, 1]\\nassert is_palindrome(i3)\\n\\ni4 = [1, 2, 3, 4, 5, 5, 4, 3, 2, 1]\\nassert is_palindrome(i4)\\n\\ni5 = [1, 2, 3, 4, 5, 5, 4, 3, 2]\\nassert not is_palindrome(i5)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Construct the task requirements\\nNext, construct the task requirements. Unlike other parameters which take a Python (JSON-like) dictionary, the task field takes a Google protobuf Struct, which is very similar to a Python dictionary. Use the json_format.ParseDict method for the conversion.\\nThe minimal fields we need to specify are:\\n\\nmulti_label: Whether True\\/False this is a multi-label (vs single) classification.\\nbudget_milli_node_hours: The maximum time to budget (billed) for training the model, where 1000 = 1 hour. For image classification, the budget must be a minimum of 8 hours.\\nmodel_type: The type of deployed model:\\nCLOUD: For deploying to Google Cloud.\\nMOBILE_TF_LOW_LATENCY_1: For deploying to the edge and optimizing for latency (response time).\\nMOBILE_TF_HIGH_ACCURACY_1: For deploying to the edge and optimizing for accuracy.\\nMOBILE_TF_VERSATILE_1: For deploying to the edge and optimizing for a trade off between latency and accuracy.\\ndisable_early_stopping: Whether True\\/False to let AutoML use its judgement to stop training early or train for the entire budget.\\n\\nFinally, create the pipeline by calling the helper function create_pipeline, which returns an instance of a training pipeline object.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nPIPE_NAME = \\\"flowers_pipe-\\\" + TIMESTAMP\\nMODEL_NAME = \\\"flowers_model-\\\" + TIMESTAMP\\n\\ntask = json_format.ParseDict(\\n {\\n \\\"multi_label\\\": False,\\n \\\"budget_milli_node_hours\\\": 8000,\\n \\\"model_type\\\": \\\"CLOUD\\\",\\n \\\"disable_early_stopping\\\": False,\\n },\\n Value(),\\n)\\n\\nresponse = create_pipeline(PIPE_NAME, MODEL_NAME, dataset_id, TRAINING_SCHEMA, task)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"As an example for downstream analyses using corrected exprssion levels, we here consider GPy to fit a non-linear Bayeisan PCA model, therbey visualizing hidden substructures between cells.\\n\",\"targets\":\"import GPy\\n\\n# Model optimization\\nYstd = Ycorr-Ycorr.mean(0)\\nYstd\\/=Ystd.std(0)\\ninput_dim = 2 # How many latent dimensions to use\\nkern = GPy.kern.RBF(input_dim,ARD=True) # ARD kernel\\nm = GPy.models.BayesianGPLVM(Ystd, input_dim=input_dim, kernel=kern, num_inducing=40)\\nm.optimize('scg', messages=0, max_iters=2000)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A Small Simplification\\n\\nAlthough the regular solution can approximate more kinds of chemical solutions, all the effects we wish to show are produced by a simple function that replaces the regular solution model:\\n$$\\nf(\\\\phi) = W \\\\phi^2 (1-\\\\phi)^2\\n$$\\nI switch to $\\\\phi$ as a reminder of this simplification. A plot of this function and the regular solution are shown side-by-side below:\\n\",\"targets\":\"def regularSolution(GA, GB, XB, omega, temperature):\\n return omega*(1.0-XB)*XB+(1.0-XB)*GA+XB*GB+8.314*temperature*((1-XB)*np.log(1-XB)+XB*np.log(XB))\\n\\ndef simplifiedSolution(XB, W):\\n return (1.0-XB)**2*XB**2*W\\n\\ndef myfig3(omega, W, temperature):\\n \\\"\\\"\\\"\\n This function ...\\n \\\"\\\"\\\"\\n GA = 1.0\\n GB = 1.0\\n \\n XB = np.linspace(0.01,0.99,50)\\n \\n temperatureSpace = np.linspace(1.0,100.0,10)\\n y1 = regularSolution(GA, GB, XB, omega, temperature)\\n greySolutionLines = [regularSolution(GA, GB, XB, omega, greyT) for greyT in temperatureSpace]\\n \\n wSpace = np.linspace(0.01,100.0,10)\\n y2 = simplifiedSolution(XB, W)\\n greyWLines = [simplifiedSolution(XB, greyW) for greyW in wSpace]\\n \\n fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(14,8))\\n plt.tight_layout(pad=5.0)\\n \\n #for greyLine in greyMagLines:\\n # axes[0].plot(eta, greyLine, 'grey', alpha=0.3)\\n #for greyLine in greyPhiLines:\\n # axes[1].plot(eta, greyLine, 'grey', alpha=0.3)\\n #axes[0].set_ylim(0,4)\\n #axes[0].plot(eta, y1, 'r', label=r\\\"$MF(\\\\eta,\\\\xi)$\\\")\\n #axes[1].set_ylim(0,180)\\n #axes[1].plot(eta, y2, 'b', label=r\\\"$\\\\phi(\\\\eta,\\\\xi)$\\\")\\n \\n for greyLine in greySolutionLines:\\n axes[0].plot(XB, greyLine, 'black', alpha=0.9)\\n axes[0].plot(XB, y1, 'r', label=r\\\"Regular Solution\\\", linewidth=4)\\n axes[0].annotate('GA='+str(GA)+'\\\\n'+'GB='+str(GB),xy=(0,40), fontsize=15)\\n\\n for greyLine in greyWLines:\\n axes[1].plot(XB, greyLine, 'black', alpha=0.9)\\n axes[1].plot(XB, y2, 'g', label=r\\\"$W \\\\phi^2 (1-\\\\phi)^2$\\\", linewidth=4)\\n axes[1].set_ylim(0.0,4.0)\\n\\n #axes.plot(XB, y, 'r', label=r\\\"$G_{soln}$\\\")\\n #axes.legend()\\n #axes.grid(True, linestyle='dotted')\\n #axes.set_ylim(-600,200)\\n #axes.set_ylabel(r\\\"$G_{soln}$\\\")\\n #axes.set_xlabel(r\\\"$X_B$\\\")\\n \\n for ax in axes:\\n ax.legend(loc=\\\"upper right\\\", fontsize=15)\\n ax.set_ylabel(r\\\"$G_{soln}$\\\", fontsize=20)\\n ax.xaxis.set_tick_params(labelsize=15)\\n ax.yaxis.set_tick_params(labelsize=15)\\n\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Digital Text Analysis.ipynb\\\".\\nThe first task is:\\nUsing the split() method, we split our original sentence into a word list along instances of whitespace characters. Note that, in technical terms, the variable type of text is different from that of the newly created variable words:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(type(text))\\nprint(type(words))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!deepdive compile\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIn this notebook, we are going to write our application in this app.ddlog one part at a time.\\nWe can check if the code make sense by asking DeepDive to compile it.\\nDeepDive automatically compiles our application whenever we execute things after making changes, but we can also do this manually by running:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Bad things are bad\\nBut don't worry - it's not just the computer that has trouble understanding what roles words play in a sentence. Some sentences are ambiguous or difficult for humans, too:\\n\\nMr\\/NNP Calhoun\\/NNP never\\/RB got\\/VBD around\\/RP to\\/TO joining\\/VBG\\nAll\\/DT we\\/PRP gotta\\/VBN do\\/VB is\\/VBZ go\\/VB around\\/IN the\\/DT block\\/NN\\nSuite\\/NNP Mondant\\/NNP costs\\/VBZ around\\/RB 250\\/CD\\n\\nThis is a great example of why you will always have error - sometimes even a human can't tell the difference, and in those cases, the computer will fail, too.\\nPart-of-Speech Tagging - Runtime\\nPart-of-Speech taggers have achieved quite high quality results in recent years, but still suffer from underwhelming performance. This is because they usually are not heuristic-based, or derived from empirical rules, but rather use machine-learned models that require significant pre-processing and feature generation to predict tags. In practice, Data Scientists might develop their own heuristics or domain-trained models for POS tagging. This is a great example of a case where domain-specificity of the model will improve the accuracy, even if based on heuristics alone (see further reading).\\nSomething important to note: NLTK, a popular tool that is underneath much of TextBlob, is a massive framework that was built originally as an academic and teaching tool. It was not built with production performance in mind.\\nUnfortunately, as Matthew Honnibal notes,\\n\\nUp-to-date knowledge about natural language processing is mostly locked away in academia.\\n\\nFurther Reading:\\n\\nA Good Part-of-Speech Tagger in about 200 Lines of Python\\nExploiting Wiktionary for Lightweight Part-of-Speech Tagging for Machine Learning Tasks\\n\\n\\nQ2: What tone does this transcript take?\\nSentiment refers to the emotive value of language.\\nPolarity is the generalized sentiment measured from negative to positive. A sentiment polarity score can be calculated in a range of [-1.0,1.0].\\nSo the general polarity of the text is:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint t.sentiment.polarity\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Project_search.ipynb\\\".\\nThe first task is:\\nenter different queries\\nCan you write Python code for it?\\n\",\"targets\":\"\\nresults = get_results_tf('ghouls and ghosts', idx)\\nprint_results(results, 10)\\n\\nimport pandas as pd\\nfrom bokeh.plotting import output_notebook, show\\nfrom bokeh.charts import Bar\\nfrom bokeh.charts.attributes import CatAttr\\n#from bokeh.models import ColumnDataSource\\n\\ndf = pd.DataFrame({'term':[x for x in idx.keys()],'freq':[len(x) for x in idx.values()]})\\n\\noutput_notebook(hide_banner=True)\\np = Bar(df.sort_values('freq', ascending=False)[:30], label=CatAttr(columns=['term'], sort=False), values='freq',\\n plot_width=800, plot_height=400)\\nshow(p)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Affichons la trajectoire\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npyplot.figure(figsize=(10,10))\\npyplot.grid(True)\\npyplot.xlabel('$x$')\\npyplot.ylabel('$y$')\\npyplot.plot(dataLT[:,0],dataLT[:,1], 'b-', label='Lune')\\npyplot.plot(dataAT[:,0],dataAT[:,1], 'r-', label='Astéroïde')\\npyplot.title('Positions de la Lune et de l\\\\'astéroïde dans le repère de la Terre')\\npyplot.legend();\\npyplot.show();\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Machine Learning Dojo - Part I.ipynb\\\".\\nThe first task is:\\nReferences:\\n\\nFast Style Transfer\\nTensorflow Tutorials\\n\\nPython basics\\nVariables\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# String\\nstring = 'Machine learning '\\nstring2 = ' dojo '\\nstring3 = ' part I'\\nprint string + string2 + string3\\nprint 'String variable type is: {}'.format(type(string))\\n\\n# Integers\\nnumber = 10\\nnumber2 = 20\\nnumber3 = 30\\nprint number + number2 + number3\\nprint 'number variable type is: {}'.format(type(number))\\n\\n# Booleans\\nboolean = True\\nboolean2 = True\\nboolean3 = False\\nprint boolean and boolean2 or boolean3\\nprint 'bolean variable type is: {}'.format(type(boolean))\\n\\n# Floating point numbers\\nfloating = 3.14\\nfloating2 = 2.79\\nfloating3 = 10.01\\nprint floating + floating2 + floating3\\nprint 'floating variable type is: {}'.format(type(floating))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# EXERCICIO\\nparseMonthYear = lambda x: '{}-{}'.format(x.month, x.year)\\n\\ncrimes = map(lambda x: x[0], catCount)\\n\\ndatesCrimesRDD = (CrimeHeadlessRDD\\n .\\n .\\n .\\n .\\n .\\n .cache()\\n )\\n\\nprint datesCrimesRDD.take(1)\\n\\nassert datesCrimesRDD.take(1)[0][1][u'KIDNAPPING']==12,'valores incorretos'\\nprint 'ok'\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n(3c) Gráfico de Dispersão\\nO gráfico de dispersão é utilizado para visualizar correlações entre as variáveis. Com esse gráfico é possível observar se o crescimento da quantidade de uma categoria está relacionada ao crescimento\\/decrescimento de outra (mas não podemos dizer se uma causa a outra).\\nNa primeira parte do exercício calcularemos a correlação entre os diferentes tipos de crime. Para isso primeiro precisamos construir uma RDD em que cada registro corresponde a uma data o valor contido nele é a quantidade de crimes de cada tipo.\\nDiferente dos exercícios anteriores, devemos manter essa informação como uma lista de valores em que todos os registros sigam a mesma ordem da lista de crimes.\\nO primeiro passo é criar uma RDD com a tupla ( (Mes-Ano, Crime), 1 ) e utilizá-la para gerar a tupla ( (Mes-Ano,Crime) Quantidade ).\\nMapeamos essa RDD para definir Mes-Ano como chave e agrupamos em torno dessa chave, gerando uma lista de quantidade de crimes em cada data. Aplicamos a função dict() nessa lista para obtermos uma RDD no seguinte formato: (Mes-Ano, {CRIME: quantidade}).\\nAlém disso, vamos criar a variável crimes contendo a lista de crimes contidas na lista de pares catCount computada anteriormente.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Confusion matrix\\n\",\"targets\":\"u.plot_confusion_matrix(y_test, nb_classes, predicted_classes)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Documentation\\/Tutorial librería Simplex.py.ipynb\\\".\\nThe first task is:\\ncalculateVarWhichExit\\nEste método recibe en un array de numpy las variables o columnas que pertenecen a la iteración(deben aparecer ordenadas en función de lo que se esté realizando en el problema), y en otro array de numpy, los valores de la regla de salida, que deben ser rational o Nan. Si los parámetros introducidos son correctos, devuelve el valor de la variable que saldrá en esta iteración, o None, en caso de que todos los valores sean Nan. En caso de no recibir como parámetro un array de numpy, devolverá None. Ejemplos:\\nCan you write Python code for it?\\n\",\"targets\":\"\\noutputRuleValues=np.array([rational(1,2),rational(-3,-2),rational(0,1),rational(5,7)])\\ncolumnsOfIteration=np.array([0,2,3])\\nSimplex.calculateVarWhichExit(columnsOfIteration,outputRuleValues)\\n\\n#Si los valores de la regla de salida, son todos negativos o divididos por 0, es decir, le pasamos Nan, devuelve None\\noutputRuleValues=np.array([np.nan,np.nan,np.nan,np.nan])\\nprint(Simplex.calculateVarWhichExit(columnsOfIteration,outputRuleValues))\\n\\n# Si recibe algo que no es un array de numpy en ambos parámetros, devuelve None\\noutputRuleValues=np.array([1,-3,0,5])\\nprint(Simplex.calculateVarWhichExit(4,outputRuleValues))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Compared to the standard neutral model prediction, it seems that only the first frequency class has a markedly reduced residual with this model (about 20 standard deviations).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\np = np.array(df.iloc[0, 0:2])\\nprint(p)\\nexpected_sfs = func_ex(p_init, ns, pts_l)\\ndadi.Plotting.plot_1d_comp_multinom(expected_sfs.fold()[:19], fs_ery[:19], residual='linear')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"9번 줄부터 도시 정보에 대한 파일들 정보가 들어있음을 확인 할 수 있다.\\n처음 10개 도시 정보를 확인해보자.\\n\",\"targets\":\"city_name_info_line[8:18]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# get marginal 1D spectra from the 2D spectrum\\n\\nfsm_ery = sfs2d.marginalize([1])\\nfsm_par = sfs2d.marginalize([0])\\n\\n# get original 1D spectra\\n\\n# import 1D unfolded spectrum of ery\\nfs_ery_unfolded = dadi.Spectrum.from_file('ERY.unfolded.sfs')\\nfs_ery = fs_ery_unfolded.fold()\\n\\n# import 1D unfolded spectrum of par\\nfs_par_unfolded = dadi.Spectrum.from_file('PAR.unfolded.sfs')\\nfs_par = fs_par_unfolded.fold()\\n\\npylab.plot(fs_par, 'go-', label='individual', linewidth=2.5, markersize=12)\\npylab.plot(fsm_par, 'g>--', label='marginal', linewidth=2.5, markersize=12)\\npylab.grid()\\npylab.title('PAR')\\npylab.legend()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNote, that the fitting of 1D models to the spectra of each population had indicated a population size reduction for both populations and more so for parallelus, which seems to contradict what this 2D model says about the two populations.\\ncompare marginal spectra\\nAs mentioned above, the population size history inferred from the 2D spectrum contradicts what was inferred from the individual 1D spectra of each population. The 2D spectrum is not computed from the same number of sites as the two 1D spectra. While inclusion of a site in each 1D spectrum required read data from at least 9 individuals, the 2D spectrum required read data from at least 9 individuals in both populations. That is because each population's SAF files were created with minInd 9 (see lines 1426-1435 in assembly.sh). When estimating the 2D SFS with realSFS only sites that occurred in each population's SAF files were included (see lines 1661-1664 in assembly.sh).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# TODO: Import 'GridSearchCV', 'make_scorer', and any other necessary libraries\\n\\n# TODO: Initialize the classifier\\nclf = None\\n\\n# TODO: Create the parameters list you wish to tune\\nparameters = None\\n\\n# TODO: Make an fbeta_score scoring object\\nscorer = None\\n\\n# TODO: Perform grid search on the classifier using 'scorer' as the scoring method\\ngrid_obj = None\\n\\n# TODO: Fit the grid search object to the training data and find the optimal parameters\\ngrid_fit = None\\n\\n# Get the estimator\\nbest_clf = grid_fit.best_estimator_\\n\\n# Make predictions using the unoptimized and model\\npredictions = (clf.fit(X_train, y_train)).predict(X_test)\\nbest_predictions = best_clf.predict(X_test)\\n\\n# Report the before-and-afterscores\\nprint \\\"Unoptimized model\\\\n------\\\"\\nprint \\\"Accuracy score on testing data: {:.4f}\\\".format(accuracy_score(y_test, predictions))\\nprint \\\"F-score on testing data: {:.4f}\\\".format(fbeta_score(y_test, predictions, beta = 0.5))\\nprint \\\"\\\\nOptimized Model\\\\n------\\\"\\nprint \\\"Final accuracy score on the testing data: {:.4f}\\\".format(accuracy_score(y_test, best_predictions))\\nprint \\\"Final F-score on the testing data: {:.4f}\\\".format(fbeta_score(y_test, best_predictions, beta = 0.5))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nImproving Results\\nIn this final section, you will choose from the three supervised learning models the best model to use on the student data. You will then perform a grid search optimization for the model over the entire training set (X_train and y_train) by tuning at least one parameter to improve upon the untuned model's F-score. \\nQuestion 3 - Choosing the Best Model\\nBased on the evaluation you performed earlier, in one to two paragraphs, explain to CharityML which of the three models you believe to be most appropriate for the task of identifying individuals that make more than \\\\$50,000.\\nHint: Your answer should include discussion of the metrics, prediction\\/training time, and the algorithm's suitability for the data.\\nAnswer: \\nQuestion 4 - Describing the Model in Layman's Terms\\nIn one to two paragraphs, explain to CharityML, in layman's terms, how the final model chosen is supposed to work. Be sure that you are describing the major qualities of the model, such as how the model is trained and how the model makes a prediction. Avoid using advanced mathematical or technical jargon, such as describing equations or discussing the algorithm implementation.\\nAnswer: \\nImplementation: Model Tuning\\nFine tune the chosen model. Use grid search (GridSearchCV) with at least one important parameter tuned with at least 3 different values. You will need to use the entire training set for this. In the code cell below, you will need to implement the following:\\n- Import sklearn.grid_search.GridSearchCV and sklearn.metrics.make_scorer.\\n- Initialize the classifier you've chosen and store it in clf.\\n - Set a random_state if one is available to the same state you set before.\\n- Create a dictionary of parameters you wish to tune for the chosen model.\\n - Example: parameters = {'parameter' : [list of values]}.\\n - Note: Avoid tuning the max_features parameter of your learner if that parameter is available!\\n- Use make_scorer to create an fbeta_score scoring object (with $\\\\beta = 0.5$).\\n- Perform grid search on the classifier clf using...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Oriol\\/Optative_exercises.ipynb\\\".\\nThe first task is:\\nExercise 3.3\\nRepeat the $a_1$,$a_2$ likelihood fit for m different montecarlo generated samples in order to estimate the variance of $a_1^{ML}$ and $a_2^{ML}$.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nm = 1000\\na1_MCvec = np.empty(m)\\na2_MCvec = np.empty(m)\\nfor i in xrange(m):\\n i_sample = try_reject(pdf_3,N,-1,1,.9,2,a1,a2)\\n # Estimate a1 and a2 using the derivatives of l, finding its roots numerically\\n a1_MCvec[i],a2_MCvec[i] = opt.fsolve(d_likelihood,np.array([.5,.5]),args=(i_sample))\\n\\nprint 'MC ML estimate:\\\\n\\\\ta1: mean=%.2g; std=%.2g\\\\n\\\\ta2: mean=%.2g; std=%.2g' %(np.mean(a1_MCvec),np.std(a1_MCvec),\\n np.mean(a2_MCvec),np.std(a2_MCvec))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"11. 기초 확률론4 - 상관 관계\\/01. 결합, 주변, 조건부 확률 밀도 함수.ipynb\\\".\\nThe first task is:\\n위에서 예로 든 연속 확률 변수의 경우에 주변 확률 밀도 함수를 계산하면 다음과 같다.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfig = plt.figure()\\nax = fig.gca(projection='3d')\\nax.contour(XX, YY, ZZ, levels=np.linspace(0, 0.04, 30), alpha=0.3)\\nax.plot(yy, ZZ.mean(axis=1), zdir='x', lw=3)\\nax.plot(xx, ZZ.mean(axis=0), zdir='y', lw=3)\\nax.set_xlabel(\\\"x\\\")\\nax.set_ylabel(\\\"y\\\")\\nax.set_title(\\\"Marginal Probability Density\\\")\\nax.view_init(50, -80)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2. Compute the LOOCV errors that result from fitting the following four models using least squares: Linear, Quadratic, Cubic and Quartic.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfor deg in range(1, 5):\\n print('{}\\\\nPolynomial Model Degree: {}\\\\n'.format('*' * 80, deg))\\n sim.linear_leave_one_out(degree=deg)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"6. How many of the claims were granted, how many denied?\\n\",\"targets\":\"end = df['Disposition'].value_counts()\\nend\\n\\nplt.style.use('ggplot')\\nend.plot(kind='pie')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Build the Neural Network\\nYou'll build the components necessary to build a Sequence-to-Sequence model by implementing the following functions below:\\n- model_inputs\\n- process_decoding_input\\n- encoding_layer\\n- decoding_layer_train\\n- decoding_layer_infer\\n- decoding_layer\\n- seq2seq_model\\nInput\\nImplement the model_inputs() function to create TF Placeholders for the Neural Network. It should create the following placeholders:\\n\\nInput text placeholder named \\\"input\\\" using the TF Placeholder name parameter with rank 2.\\nTargets placeholder with rank 2.\\nLearning rate placeholder with rank 0.\\nKeep probability placeholder named \\\"keep_prob\\\" using the TF Placeholder name parameter with rank 0.\\n\\nReturn the placeholders in the following the tuple (Input, Targets, Learing Rate, Keep Probability)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef model_inputs():\\n \\\"\\\"\\\"\\n Create TF Placeholders for input, targets, and learning rate.\\n :return: Tuple (input, targets, learning rate, keep probability)\\n \\\"\\\"\\\"\\n # TODO: Implement Function\\n \\n inputs = tf.placeholder(tf.int32, [None, None], name='input')\\n targets = tf.placeholder(tf.int32, [None, None])\\n learn_rate = tf.placeholder(tf.float32)\\n keep_prob = tf.placeholder(tf.float32, name='keep_prob')\\n \\n return inputs, targets, learn_rate, keep_prob\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_model_inputs(model_inputs)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%matplotlib inline\\n%run ..\\\\PySimplex\\\\SimplexSolver.py --input ..\\\\Files\\\\file2.txt --graphic\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nMediante el siguiente comando, además de lo que nos proporcionaban las anteriores ejecuciones, se puede añadir la solución gráfica(solo se puede obtener cuando el problema tiene dos variables):\\n python SimplexSolver.py --input file.txt --expl --graphic\\n\\nA continuación, se puede ver la salida(nótese que en su ejecución debe cambiar \\\"%run\\\", por python):\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Day2\\/SVC-basic.ipynb\\\".\\nThe first task is:\\nIn the above example, linear SVM is attemped to find the line that seperates the two classes \\nand ensure maximum margin. \\nmaximum margin - The distance from the points on either size of the group to the line is maximized. This is determined by the hyperplane pass through the suporting vectors.\\nThe selected support vectors can be used to define the margins. \\nThe plane found by SVM would usually be slight different from the logistic regression since they optimize different properties. \\nIntroduce the Kernals and their parameters:\\n - linear: C\\n - RBF: gamma, C\\n - Polynomial: degree, coef0, gamma\\nC>0 is the penalty parameter of the error term (data points falls into the wrong class), and linear SVM with small C behaves more like logistic regression.\\nLet's compare the properties of the three kernels using three examples. \\nWe use the make_classification function from scikit-learn to create three different \\ntype of data sets: \\n - two classes that makes a circle together. \\n - two classes that can be sepearted by a circle.\\n - two linear separable classes.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnames = ['LinearSVC','LinearSVC, C=0.025','SVCRBF,gamma=2','SVCRBF,gamma=10','SVCPOLY,degree=2','SVCPOLY,degree=4,coef=10,gamma=0.1']\\nclassifiers=[\\n SVC(kernel=\\\"linear\\\"),\\n SVC(kernel=\\\"linear\\\", C=0.025), \\n SVC(gamma=2),\\n SVC(gamma=10),\\n SVC(kernel=\\\"poly\\\",degree=2),\\n SVC(kernel=\\\"poly\\\",degree=4,coef0=10,gamma=0.1)\\n ]\\nX, y = make_classification(n_features=2, n_redundant=0, n_informative=2,\\n random_state=1, n_clusters_per_class=1)\\nrng = np.random.RandomState(2)\\nX += 2 * rng.uniform(size=X.shape)\\nlinearly_separable = (X, y)\\n\\ndatasets = [make_moons(noise=0.4, random_state=0),\\n make_circles(noise=0.2, factor=0.5, random_state=1),\\n linearly_separable\\n ]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# PROPERTY ID - DO NOT EDIT ! \\nDOC.set_id('cmip6.ocean.boundary_forcing.tracers.sunlight_penetration.extinction_depth') \\n\\n# PROPERTY VALUE: \\n# Set as follows: DOC.set_value(\\\"value\\\") \\n# TODO - please enter value(s)\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n40.3. Extinction Depth\\nIs Required: FALSE Type: STRING Cardinality: 0.1\\nDescribe and list extinctions depths for sunlight penetration scheme (if applicable).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Janacare_User-Segmentation_dataset_Aug2014-Apr2016.ipynb\\\".\\nThe first task is:\\nLabelling the Raw data\\nNow comes the code that will based on the rules mentioned below label the provided data, so it can be used as trainning data for the classifer.\\nThis tables defines the set of rules used to assign labels for Traning data\\n| label | age_on_platform | last_activity | num_modules_comsumed | num_of_days_food_tracked | num_glucose_tracked | watching_videos |\\n|---------------------|----------------------|---------------------------|-----------------------------|--------------------------|-----------------------------|------------------|\\n| Generic (ignore) | Converted to days | to be Measured from 16Apr | Good >= 3\\/week Bad < 3\\/week | Good >= 30 Bad < 30 | Good >= 4\\/week Bad < 4\\/week | Good = 1 Bad = 0 |\\n| good_new_user = 1 | >= 30 days && < 180 | <= 2 days | >= 12 | >= 20 | >= 16 | Good = 1 |\\n| bad_new_user = 2 | >= 30 days && < 180 | > 2 days | < 12 | < 20 | < 16 | Bad = 0 |\\n| good_mid_term_user = 3 | >= 180 days && < 360 | <= 7 days | >= 48 | >= 30 | >= 96 | Good = 1 |\\n| bad_mid_term_user = 4 | >= 180 days && <360 | > 7 days | < 48 | < 30 | < 96 | Bad = 0 |\\n| good_long_term_user = 5 | >= 360 days | <= 14 days | >= 48 | >= 30 | >= 192 | Good = 1 |\\n| bad_long_term_user = 6 | >= 360 days | > 14 days | < 48 | < 30 | < 192 | Bad = 0 |\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# This if else section will bin the rows based on the critiria for labels mentioned in the table above\\n\\nuser_data_imputed_data_frame_labeled = user_data_imputed_data_frame\\n\\nfor index, row in user_data_imputed_data_frame.iterrows():\\n \\n if row[\\\"age_on_platform\\\"] >= np.timedelta64(30, 'D') and row[\\\"age_on_platform\\\"] < np.timedelta64(180, 'D'): \\n if row['last_activity'] <= np.datetime64(2, 'D') and\\\\\\n row['num_modules_consumed'] >= 12 and\\\\\\n row['num_of_days_food_tracked'] >= 20 and\\\\\\n row['num_glucose_tracked'] >= 16 and\\\\\\n row['watching_videos'] == 1:\\n user_data_imputed_data_frame_labeled.set_value(index, 'label', 1)\\n else:\\n user_data_imputed_data_frame_labeled.set_value(index, 'label', 2)\\n \\n elif row[\\\"age_on_platform\\\"] >= np.timedelta64(180, 'D') and row[\\\"age_on_platform\\\"] < np.timedelta64(360, 'D'):\\n if row['last_activity'] <= np.datetime64(7, 'D') and\\\\\\n row['num_modules_consumed'] >= 48 and\\\\\\n row['num_of_days_food_tracked'] >= 30 and\\\\\\n row['num_glucose_tracked'] >= 96 and\\\\\\n row['watching_videos'] == 1:\\n user_data_imputed_data_frame_labeled.set_value(index, 'label', 3)\\n else:\\n user_data_imputed_data_frame_labeled.set_value(index, 'label', 4)\\n \\n elif row[\\\"age_on_platform\\\"] >= np.timedelta64(360, 'D'):\\n if row['last_activity'] <= np.datetime64(14, 'D') and\\\\\\n row['num_modules_consumed'] >= 48 and\\\\\\n row['num_of_days_food_tracked'] >= 30 and\\\\\\n row['num_glucose_tracked'] >= 192 and\\\\\\n row['watching_videos'] == 1:\\n user_data_imputed_data_frame_labeled.set_value(index, 'label', 5)\\n else:\\n user_data_imputed_data_frame_labeled.set_value(index, 'label', 6)\\n else:\\n user_data_imputed_data_frame_labeled.set_value(index, 'label', 0)\\n \\nuser_data_imputed_data_frame_labeled['label'].unique()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"6.A.2. Calculate Constraint Pearson Correlation\\nIn the case of MovieLens data, it means any ratings greater than 3 (aka positive ratings).\\n6.A.2. Pearson's User-Based Approach: comparing USERS similarities\\nThis is the same as Pearson's User-Based Approach with the exception that it filters out ratings that are 2 or less.\\n6.A.2. Constraint Pearson's Item-Based Approach: comparing MOVIES similarities\\nThis is the same as Pearson's Item-Based Approach with the exception that it filters out ratings that are 2 or less.\\n6.B. Calculate Probabilistic Similarity\\n6.B. Probabilistic's Item-Based Approach: comparing MOVIES similarity\\nAccording to the article, this is supposed to be the best item-based approach. \\n6.C.1. Calculate Cosine Similarity\\n6.C.2. Calculate Adjusted Cosine Similarity\\n6.D. Comparing Similarities' Measurement\\nGraph user-based approaches using the deviation prediction scheme (MAE) and different neighborhood sizes (K)\\n7. Develop Model\\nComparing distance measures for model-based approaches using the mean item rating prediction scheme and different number of clusters (K)\\n* Manhattan\\n* Euclidian\\nComparing prediction schemes for model-based approaches using the euclidian distance and different numbers of clusters (K)\\n* Mean Item\\n* Bayes MAE\\nComparing different clustering algorithms for model-based approaches using the euclidian distance, the mean item rating prediction scheme, and different numbers of clusters (K)\\n* K-Means\\n* Bisecting\\n* LAC\\n* SSC\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# divide movielens data into 10 parts to perform 10-fold cross-validation\\n# training model using 9 parts\\n# test model using last part\\n\\n\\n# results are better when default ratings are based on item information than when they are based on user information\\n# using mean rating is better than using majority rating\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Creating variables\\nNow let's add some variables and store some data in them. \\n\\nA variable has a name, a type, a shape, and some data values. \\nThe shape of a variable is specified by a tuple of dimension names. \\nA variable should also have some named attributes, such as 'units', that describe the data.\\n\\nThe createVariable method takes 3 mandatory args.\\n\\nthe 1st argument is the variable name (a string). This is used as the key to access the variable object from the variables dictionary.\\nthe 2nd argument is the datatype (most numpy datatypes supported). \\nthe third argument is a tuple containing the dimension names (the dimensions must be created first). Unless this is a NETCDF4 file, any unlimited dimension must be the leftmost one.\\nthere are lots of optional arguments (many of which are only relevant when format='NETCDF4') to control compression, chunking, fill_value, etc.\\n\",\"targets\":\"# Define two variables with the same names as dimensions,\\n# a conventional way to define \\\"coordinate variables\\\".\\nlat = ncfile.createVariable('lat', np.float32, ('lat',))\\nlat.units = 'degrees_north'\\nlat.long_name = 'latitude'\\n#\\nlon = ncfile.createVariable('lon', np.float32, ('lon',))\\nlon.units = 'degrees_east'\\nlon.long_name = 'longitude'\\n#\\ntime = ncfile.createVariable('time', np.float64, ('time',))\\ntime.units = 'hours since 1800-01-01'\\ntime.long_name = 'time'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"$\\\\frac{1}{4\\\\pi\\/3(30Mpc)^313.5Gyr}=\\\\frac{1}{4\\\\pi\\/32700013.5 {Gpc}^3 yr}$\\n\",\"targets\":\"scale=len(merger)\\/(4.*pi\\/3.*30**3)\\/13.5\\n\\nfrom scipy.interpolate import interp1d\\nf2=interp1d(merge_curve[0],merge_curve[1]*scale,kind='cubic')\\n\\nf2(13.5)\\n\\nplot(merge_curve[0],merge_curve[1]*scale)\\ntitle(\\\"merger event rate, per Gpc^3 per year, in local frame\\\")\\n\\nfrom scipy.integrate import quad\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"All'identificatore lista01 è associata una lista che contiene quattro elementi:\\n\\nuna stringa;\\nun numero intero;\\nun numero in virgola mobile;\\nuna lista di stringhe.\\n\\nLe liste sono indicizzabili, teniamo presente che l'indice del primo elemento di una lista è sempre il numero zero.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint(lista01[0])\\nprint(lista01[1])\\nprint(lista01[2])\\nprint(lista01[3])\\nprint(lista01[3][0])\\nprint(lista01[3][1])\\nprint(lista01[3][2])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# -*- coding: utf-8 -*-\\nfrom selenium import webdriver\\nfrom selenium.webdriver.common.by import By\\nfrom selenium.webdriver.common.keys import Keys\\nfrom selenium.webdriver.support.ui import Select\\nfrom selenium.common.exceptions import NoSuchElementException\\nfrom selenium.common.exceptions import NoAlertPresentException\\nimport time, re\\n\\ndriver = webdriver.Firefox()\\ndriver.implicitly_wait(3)\\nbase_url = \\\"http:\\/\\/www.agoda.com\\\"\\n\\ndriver.get(base_url + \\\"\\/zh-tw\\/city\\/taipei-tw.html\\\")\\ndriver.find_element_by_id(\\\"CheckInMonthYear\\\").click()\\n\\ndriver.implicitly_wait(1)\\nSelect(driver.find_element_by_id(\\\"CheckInMonthYear\\\")).select_by_visible_text(u\\\"2015年11月\\\")\\ndriver.implicitly_wait(1)\\ndriver.find_element_by_id(\\\"search-submit\\\").click()\\ndriver.implicitly_wait(1)\\ndriver.implicitly_wait(3)\\ndriver.find_element_by_link_text(u\\\"下一頁\\\").click()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nhttp:\\/\\/release.seleniumhq.org\\/selenium-ide\\/2.9.0\\/selenium-ide-2.9.0.xpi\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"And then convert the autoencoder to a regular neural network for classification:\\n\",\"targets\":\"conv_nn = sg.convert_to_neural_network(ae, sg.create_layer(\\\"NeuralSoftmaxLayer\\\", num_neurons=10), 0.01)\\n\\n# train the network\\nconv_nn.put('epsilon', 0.0)\\nconv_nn.put('max_num_epochs', 50)\\nconv_nn.put('labels', Ytrain)\\n\\n# start training. this might take some time\\n_ = conv_nn.train(Xtrain)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Batches\\nImplement get_batches to create batches of input and targets using int_text. The batches should be a Numpy array with the shape (number of batches, 2, batch size, sequence length). Each batch contains two elements:\\n- The first element is a single batch of input with the shape [batch size, sequence length]\\n- The second element is a single batch of targets with the shape [batch size, sequence length]\\nIf you can't fill the last batch with enough data, drop the last batch.\\nFor exmple, get_batches([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 2, 3) would return a Numpy array of the following:\\n```\\n[\\n # First Batch\\n [\\n # Batch of Input\\n [[ 1 2 3], [ 7 8 9]],\\n # Batch of targets\\n [[ 2 3 4], [ 8 9 10]]\\n ],\\n# Second Batch\\n [\\n # Batch of Input\\n [[ 4 5 6], [10 11 12]],\\n # Batch of targets\\n [[ 5 6 7], [11 12 13]]\\n ]\\n]\\n```\\n\",\"targets\":\"def get_batches(int_text, batch_size, seq_length):\\n \\\"\\\"\\\"\\n Return batches of input and target\\n :param int_text: Text with the words replaced by their ids\\n :param batch_size: The size of batch\\n :param seq_length: The length of sequence\\n :return: Batches as a Numpy array\\n \\\"\\\"\\\"\\n # TODO: Implement Function\\n slice_size = batch_size*seq_length\\n n_batches = int(len(int_text)\\/slice_size)\\n inputs = np.array(int_text[:n_batches*slice_size])\\n targets = np.array(int_text[1:n_batches*slice_size + 1])\\n inputs = np.stack(np.split(inputs,batch_size))\\n targets = np.stack(np.split(targets, batch_size))\\n batches = []\\n for b in range(n_batches):\\n x = inputs[:,b*seq_length:(b+1)*seq_length]\\n y = targets[:,b*seq_length: (b+1)*seq_length]\\n batches.append([x,y])\\n batches = np.array(batches)\\n return batches\\n\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_get_batches(get_batches)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Insight-Demo-Roadset62.ipynb\\\".\\nThe first task is:\\nMost Valuable Features\\n\\nRank our top most valuable features\\nSee if any make obvious sense\\nPerhaps use only useful features in future iterations\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfeatures = full_df.drop(['S:G2SEM','targetPos'], axis=1).columns.values\\nimportances = rfc.feature_importances_\\nindices = np.argsort(importances)[::-1]\\n\\n# Print the feature ranking\\nprint(\\\"Feature ranking:\\\")\\n\\nuseful_feature_list = []\\nfor f in range(20):\\n print(\\\"%d. Feature '%s' (%f)\\\" % (f + 1, features[indices[f]], importances[indices[f]]))\\n useful_feature_list.append(features[indices[f]])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapter6\\/6-Linked_Structures.ipynb\\\".\\nThe first task is:\\nThis is will give us just the containers that we can store data into.\\nCan you write Python code for it?\\n\",\"targets\":\"\\na = ListNode(11)\\nb = ListNode(52)\\nc = ListNode(18)\\n\\nprint(a)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"18-pyspark-01.ipynb\\\".\\nThe first task is:\\n1. Getting Started\\nSpark stores data in memory. This memory space is represented by variable sc (SparkContext).\\nCan you write Python code for it?\\n\",\"targets\":\"\\n!cypress-kinit\\n!klist\\n\\nimport sys\\nimport os\\n\\nsys.path.insert(0, '\\/usr\\/hdp\\/current\\/spark2-client\\/python')\\nsys.path.insert(0, '\\/usr\\/hdp\\/current\\/spark2-client\\/python\\/lib\\/py4j-0.10.4-src.zip')\\n\\nos.environ['SPARK_HOME'] = '\\/usr\\/hdp\\/current\\/spark2-client\\/'\\nos.environ['SPARK_CONF_DIR'] = '\\/etc\\/hadoop\\/synced_conf\\/spark2\\/'\\nos.environ['PYSPARK_PYTHON'] = '\\/software\\/anaconda3\\/4.2.0\\/bin\\/python'\\n\\nimport pyspark\\nconf = pyspark.SparkConf()\\nconf.setMaster(\\\"yarn\\\")\\nconf.set(\\\"spark.driver.memory\\\",\\\"4g\\\")\\nconf.set(\\\"spark.executor.memory\\\",\\\"60g\\\")\\nconf.set(\\\"spark.num.executors\\\",\\\"3\\\")\\nconf.set(\\\"spark.executor.cores\\\",\\\"12\\\")\\n\\nsc = pyspark.SparkContext(conf=conf)\\n\\nsc\\n\\ntextFile = sc.textFile(\\\"\\/repository\\/gutenberg-shakespeare.txt\\\")\\n\\nprint (textFile)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!ls -lah\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nShell commands\\nShell commands must be precided by ! character, e.g.:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# print all tallies for informational purposes\\nfor name in sorted(lenDict.keys()):\\n print name, \\\":\\\", lenDict[name]\\n\\n# now to get the max length, we can sort the keys by value\\nsortedLens = sorted(lenDict, key=lenDict.get) #this returns a list of the keys sorted by value\\n\\n# this sorts from smallest to largest, so we take the last element\\nmostCommon = sortedLens[-1]\\nprint \\\"Most common length is\\\", mostCommon, \\\"nts\\\"\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n(B) Using the tally dictionary you created above, figure out which sequence length was the most common, and print it to the screen.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"02-Classification\\/isomap-pca.ipynb\\\".\\nThe first task is:\\nThere are 158 entries.\\nEach one has the classification target column, plus 24 other classes: 11 numeric and 14 nominal.\\nSee the site page for an explanation of each class.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Create some color coded labels; the actual label feature\\n# will be removed prior to executing PCA, since it's unsupervised.\\n# we're only labeling by color so you can see the effects of PCA\\n\\nlabelsCol = ['red' if i=='ckd' else 'green' for i in df.classification]\\n\\n# Get rid of nominal columns\\n#\\n\\ndf.drop(labels=['classification'], axis=1, inplace=True)\\n\\ndf = pd.get_dummies(df,columns=['rbc', 'pc', 'pcc', 'ba', 'htn', \\n 'dm', 'cad', 'appet', 'pe', 'ane'])\\n\\nprint(df.dtypes)\\n\\n# Print out and check the dataframe's dtypes. \\n#\\n\\ndf.wc = pd.to_numeric(df.wc, errors='coerce')\\ndf.rc = pd.to_numeric(df.rc, errors='coerce')\\ndf.pcv = pd.to_numeric(df.pcv, errors='coerce')\\n\\nprint(df.dtypes)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Because the last four lines of our function are devoted to evaluating a condition and returning True or False, we can write a slightly more compact version. In this example we evaluate the condition, and then return the result right away:\\n\",\"targets\":\"def is_at_rich(dna):\\n length = len(dna)\\n a_count = dna.upper().count('A')\\n t_count = dna.upper().count('T')\\n at_content = (a_count + t_count) \\/ length\\n return at_content > 0.65\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%bash\\npip install pycorenlp\\n\\nfrom pycorenlp import StanfordCoreNLP\\nnlp = StanfordCoreNLP('http:\\/\\/localhost:9000')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPretty cool, but what does NORP mean? Again, you can use spacy.explain() to find out:\\n3. EXTRA: Stanford CoreNLP\\nAnother very popular NLP pipeline is Stanford CoreNLP. You can use the tool from the command line, but there are also some useful Python wrappers that make use of the Stanford CoreNLP API, such as pycorenlp. As you might want to use this in the future, we will provide you with a quick start guide. To use the code below, you will have to do the following:\\n\\nDownload Stanford CoreNLP here.\\nInstall pycorenlp (run pip install pycorenlp in your terminal, or simply run the cell below).\\nOpen a terminal and run the following commands (replace with the correct directory names):\\ncd LOCATION_OF_CORENLP\\/stanford-corenlp-full-2018-02-27\\njava -mx4g -cp \\\"*\\\" edu.stanford.nlp.pipeline.StanfordCoreNLPServer\\n This step you will always have to do if you want to use the Stanford CoreNLP API.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Categorical Features\\nIf you know the set of all possible feature values of a column and there are only a few of them, you can use categorical_column_with_vocabulary_list. If you don't know the set of possible values in advance you can use categorical_column_with_hash_bucket\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nassigned_group = tf.feature_column.categorical_column_with_vocabulary_list('Group',['A','B','C','D'])\\n# Alternative\\n# assigned_group = tf.feature_column.categorical_column_with_hash_bucket('Group', hash_bucket_size=10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Analyzes\\/Volatile movements\\/01 Volatile movements in python and pandas 1.ipynb\\\".\\nThe first task is:\\nIdentifikace volatilní úsečky\\nVolatilní svíce identifikuji pomocí funkcionality rolling a funkce apply. Funkcionalita rolling umožnuje rozdělit pandas DataFrame na jednotlivé menší \\\"okna\\\", které bude předávat postupně funkci apply v parametru. Tzn. že v následujícím kódu se provede výpočet funkce is_bigger pro každý řádek dat uložených v spy_data. Do parametru rows se bude postupně vkládat výřez dat, obsahující 4 řádky (aktuální počátaný řádek + 3 řádky předchozí). Jako výsledek funkce is_bigger bude hodnota, zda je aktuálně počítaný řádek volatilnější, než 4 předchozí.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef is_bigger(rows):\\n result = rows[-1] > rows[:-1].max() # rows[-1] - poslední hodnota je větší než maximum z předchozích\\n return result\\n\\nspy_data['VolBar'] = spy_data['Abs(C-O)'].rolling(4).apply(is_bigger,raw=True)\\nspy_data.tail(10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#Plot the stimulus\\nplot_pattern(sim.stimulus)\\n\\nif IMPORTED_MAYAVI:\\n surface_pattern(sim.surface, sim.stimulus.spatial_pattern)\\n\\n#Make the lists numpy.arrays for easier use.\\nTAVG = numpy.array(tavg_data)\\nSAVG = numpy.array(savg_data)\\nEEG = numpy.array(eeg_data)\\n\\n#Plot region averaged time series\\nfigure(3)\\nplot(savg_time, SAVG[:, 0, :, 0])\\ntitle(\\\"Region average\\\")\\n\\n#Plot EEG time series\\nfigure(4)\\nplot(eeg_time, EEG[:, 0, :, 0])\\ntitle(\\\"EEG\\\")\\n\\n#Show them\\nshow()\\n\\nif IMPORTED_MAYAVI:\\n st = surface_timeseries(sim.surface, TAVG[:, 0, :, 0])\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPlot pretty pictures of what we just did\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Distribution 1\\np1Plus = ?\\np1Minus = ?\\n# Distribution 2\\np2Plus = ?\\np2Minus = ?\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nProblem 2: Naive Bayes on Symbols\\n\\n\\nThis problem was adopted from Naive Bayes and Text Classification I: Introduction and Theory by Sebastian Raschka and a script from the CU computer science department.\\n\\nConsider the following training set of 12 symbols which have been labeled as either + or -: \\n \\n\\n\\n\\nAnswer the following questions: \\nA: What are the general features associated with each training example? \\nIn the next part, we'll use Naive Bayes to classify the following test example: \\n\\nOK, so this symbol actually appears in the training set, but let's pretend that it doesn't. \\nThe decision rule can be defined as \\n\\nClassify ${\\\\bf x}$ as + if \\n$p(+ ~|~ {\\\\bf x} = [blue,~ square]) \\\\geq p(- ~|~ {\\\\bf x} = [blue, ~square])$ \\nelse classify sample as -\\n\\nB: To begin, let's explore the estimate of an appropriate prior for + and -. We'll define two distributions: \\nFor the first, use $$\\\\hat{p}(+)=\\\\frac{\\\\text{# of +}}{\\\\text{# of classified objects}} \\\\text{ and } \\\\hat{p}(-)=\\\\frac{\\\\text{# of -}}{\\\\text{# of classified objects}}$$ \\nFor the second, reader's choice. Take anything such that $$\\\\hat{p}(+)\\\\ge 0\\\\text{, }\\\\hat{p}(-)\\\\ge 0\\\\text{, and }\\\\hat{p}(+)+\\\\hat{p}(-)=1$$\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Batching of Training\\nFor efficiency, we operate on data in batches, so that (for instance) a GPU can operate on multiple examples simultaneously\\n\",\"targets\":\"# We'll choose a batch size, and calculate the number of batches in an \\\"epoch\\\"\\n# (approximately one pass through the data).\\nN_BATCHES = len(X_train) \\/\\/ BATCH_SIZE\\n#N_VAL_BATCHES = len(X_val) \\/\\/ BATCH_SIZE\\n\\n# For training, we want to sample examples at random in small batches\\ndef batch_gen(X_, y_, N):\\n while True:\\n idx = np.random.choice(len(y_), N)\\n yield X_[idx], y_[idx]\\n\\n# Minibatch generator(s) for the training and validation sets\\ntrain_batches = batch_gen(X_train, y_train, BATCH_SIZE)\\n#val_batches = batch_gen(X_val, y_val, BATCH_SIZE)\\n\\n# Try sampling from the batch generator.\\n# Plot an image and corresponding label from the training batcher to verify they match.\\nX_batch, y_batch = next(train_batches)\\nplt.imshow(X_batch[0].reshape((28, 28)), cmap='gray', interpolation='nearest')\\nprint(y_batch[0])\\n\\n# Plot an image and corresponding label from the validation set to verify they match.\\nX_batch, y_batch = X_val, y_val\\nplt.imshow(X_batch[0].reshape((28, 28)), cmap='gray', interpolation='nearest')\\nprint(y_batch[0])\\nX_batch.shape, y_batch.shape,\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%matlab\\n%% définition de la ligne de base\\nbase = 0.1*(ech-mean(ech))\\/mean(ech);\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n5. Ligne de base.\\nRépétez les les questions 1.1 et 1.2 avec une dérive de la ligne de base, telle que générée ci dessous.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Appendix\\nThe cells below show the process used to select the data for Problem 5\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.datasets import load_digits\\n\\nmnist = load_digits()\\nnp.save('im.npy', mnist.images[16])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Convert Dataframe to numpy array for Clustering\\n\",\"targets\":\"import numpy as np\\nA=df4.as_matrix([df4.columns[:]])\\nX=df4.as_matrix([df4.columns[[2,5]]])\\n\\n#X[:,1]=np.log(X[:,1]+1)\\n\\n\\nfrom sklearn.cluster import DBSCAN\\ndb = DBSCAN(eps=1.5, min_samples=20).fit(X)\\n\\ndb.labels_.max()\\n\\nax=plt.figure(figsize=(12,9))\\n#plt.rcParams['figure.figsize'] = (12,9)\\nplt.xlabel(\\\"Age\\\")\\nplt.ylabel(\\\"log(Fare+1)\\\")\\nplt.title(\\\"Titanic\\\")\\nplt.yscale('log')\\ncolor_list=['r','g','b','c','m','y','k']\\nfor i in xrange( -1,db.labels_.max()+1 ):\\n is_survive=(A[:,0]==1) & (db.labels_==i)\\n plt.scatter(X[is_survive,0], X[is_survive,1], marker='o',color=color_list[i])\\n \\n is_not_survive=(A[:,0]==0) & (db.labels_==i)\\n plt.scatter(X[is_not_survive,0], X[is_not_survive,1], marker='x',color=color_list[i])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Create a simple helper function to render a frame from the current state of\\n# the environment.\\nif environment_library == 'dm_control':\\n def render(env):\\n return env.physics.render(camera_id=0)\\nelif environment_library == 'gym':\\n def render(env):\\n return env.environment.render(mode='rgb_array')\\nelse:\\n raise ValueError(\\n \\\"Unknown environment library: {};\\\".format(environment_library) +\\n \\\"choose among ['dm_control', 'gym'].\\\")\\n\\ndef display_video(frames, filename='temp.mp4'):\\n \\\"\\\"\\\"Save and display video.\\\"\\\"\\\"\\n\\n # Write video\\n with imageio.get_writer(filename, fps=60) as video:\\n for frame in frames:\\n video.append_data(frame)\\n\\n # Read video and display the video\\n video = open(filename, 'rb').read()\\n b64_video = base64.b64encode(video)\\n video_tag = ('\\n훈련 단계 커스터마이징\\n자유도를 높이고 제어를 더 하려면 다음 세 단계를 사용해 자신만의 훈련 루프를 구현할 수 있습니다:\\n\\n샘플 배치를 만드는 파이썬 제너레이터나 tf.data.Dataset을 반복합니다.\\ntf.GradientTape을 사용하여 그래디언트를 계산합니다.\\ntf.keras.optimizer를 사용하여 모델의 가중치 변수를 업데이트합니다.\\n\\n기억할 점:\\n\\n클래스 상속으로 만든 층과 모델의 call 메서드에는 항상 training 매개변수를 포함하세요.\\n모델을 호출할 때 training 매개변수를 올바르게 지정했는지 확인하세요.\\n사용 방식에 따라 배치 데이터에서 모델이 실행될 때까지 모델 변수가 생성되지 않을 수 있습니다.\\n모델의 규제 손실 같은 것들을 직접 관리해야 합니다.\\n\\nv1에 비해 단순해진 것:\\n\\n따로 변수를 초기화할 필요가 없습니다. 변수는 생성될 때 초기화됩니다.\\n의존성을 수동으로 제어할 필요가 없습니다. tf.function 안에서도 연산은 즉시 실행 모드처럼 실행됩니다.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmodel = tf.keras.Sequential([\\n tf.keras.layers.Conv2D(32, 3, activation='relu',\\n kernel_regularizer=tf.keras.regularizers.l2(0.02),\\n input_shape=(28, 28, 1)),\\n tf.keras.layers.MaxPooling2D(),\\n tf.keras.layers.Flatten(),\\n tf.keras.layers.Dropout(0.1),\\n tf.keras.layers.Dense(64, activation='relu'),\\n tf.keras.layers.BatchNormalization(),\\n tf.keras.layers.Dense(10)\\n])\\n\\noptimizer = tf.keras.optimizers.Adam(0.001)\\nloss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\\n\\n@tf.function\\ndef train_step(inputs, labels):\\n with tf.GradientTape() as tape:\\n predictions = model(inputs, training=True)\\n regularization_loss = tf.math.add_n(model.losses)\\n pred_loss = loss_fn(labels, predictions)\\n total_loss = pred_loss + regularization_loss\\n\\n gradients = tape.gradient(total_loss, model.trainable_variables)\\n optimizer.apply_gradients(zip(gradients, model.trainable_variables))\\n\\nfor epoch in range(NUM_EPOCHS):\\n for inputs, labels in train_data:\\n train_step(inputs, labels)\\n print(\\\"마지막 에포크\\\", epoch)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Calucate the difference between the predicted values of y and the actual values of y, \\n# Find the square of the difference\\n# Sum the Squares\\n\\nypred_yact = [#______#\\n for a, b in zip(ypredicted, fahrenheit)] ## your code goes here (a - b)\\ndiff1squared = [#_______# \\n for a in ypred_yact] ## Your code goes here\\nsumsquares1 = sum(diff1squared) ## Your code goes here \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUsing the values of $y_{predicted}$ and $y_{actual}$, calculate the squared element by element difference of the two lists, and sum them.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Cython \\\"header\\\" file\\nThe .pxd file is similar to a header file for Cython. In other words, we can cimport <filename>.pxd in the regular Cython .pyx files to get access to functions declared in the .pxd files.\\n\",\"targets\":\"%%file cy_math.pxd\\n\\ncdef extern from \\\"c_math.h\\\":\\n double plus(double a, double b)\\n double mult(double a, double b)\\n double square(double a)\\n double acc(double *xs, int size)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Ballistische Methode\\nDie Resultate aus dem Versuch mit der ballistischen Methode können der Tabelle \\\\ref{tab:resultat_ballistisch} entnommen werden.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Show results\\n\\nimport math\\nfrom IPython.display import (\\n display, display_html, display_png, display_svg\\n)\\n\\nclass PrettyTable(list):\\n \\\"\\\"\\\" Overridden list class which takes a 2-dimensional list of\\n the form [[1,2,3],[4,5,6]], and renders HTML and LaTeX Table in\\n IPython Notebook. For LaTeX export two styles can be chosen.\\\"\\\"\\\"\\n def __init__(self, initlist=[], label=None, caption='Description missing', extra_header=None, entries_per_column=100, significant_digits=4, print_latex_longtable=True):\\n self.print_latex_longtable = print_latex_longtable\\n self.entries_per_column = entries_per_column\\n self.significant_digits = significant_digits\\n self.caption = caption\\n self.label = label\\n if extra_header is not None:\\n extra_header = [e.replace('%', '\\\\\\\\%') for e in extra_header]\\n if len(initlist[0]) != len(extra_header):\\n raise ValueError(\\\"Header list must have same length as data has columns.\\\")\\n initlist = [extra_header]+list(initlist)\\n super(PrettyTable, self).__init__(initlist)\\n\\n def latex_table_tabular(self):\\n latex = [\\\"\\\\\\\\begin{tabular}\\\"]\\n latex.append(\\\"{\\\"+\\\"|\\\".join(([\\\"l\\\"]*len(self[0])))+\\\"}\\\\n\\\")\\n for row in self:\\n latex.append(\\\" & \\\".join(map(format, row)))\\n latex.append(\\\"\\\\\\\\\\\\\\\\ \\\\n\\\")\\n latex.append(\\\"\\\\\\\\end{tabular}\\\")\\n return ''.join(latex)\\n\\n def latex_longtable(self):\\n latex = [\\\"\\\\\\\\begin{longtable}[H]{@{}\\\"]\\n l = len(self) - 1\\n li = len(self[0])\\n latex.append(\\\"l\\\" * (li * math.ceil(l \\/ self.entries_per_column)))\\n latex.append(\\\"@{}}\\\\n\\\")\\n latex.append(\\\"\\\\\\\\toprule\\\\\\\\addlinespace\\\\n\\\")\\n line = (\\\" & \\\".join(map(format, self[0])))\\n latex.append((line + \\\" & \\\") * (math.ceil(l \\/ self.entries_per_column) - 1))\\n latex.append(line)\\n latex.append(\\\"\\\\\\\\\\\\\\\\\\\\\\\\addlinespace \\\\n\\\")\\n latex.append(\\\"\\\\\\\\midrule\\\\\\\\endhead\\\\n\\\")\\n rows = []\\n rows_done = 0\\n for row in self[1:]:\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Randomly generate jitters\\njitters = np.random.randint(-max_jitter, max_jitter, size=(n_trial, n_events))\\nordering = np.argsort(jitters[:, 0])\\njitters = jitters[ordering]\\n\\n# Create one-hot matrix that encodes the location of latent events\\nevents = np.zeros((n_trial, n_time))\\nfor trial_idx, jitter in enumerate(jitters):\\n trial_event_times = np.cumsum(event_gap + jitter)\\n events[trial_idx, trial_event_times] = 1.0\\navg_event = np.zeros(n_time)\\navg_event[np.cumsum([event_gap] * n_events)] = 1.0\\n\\n# Convolve latent events with an exponential filter\\nimpulse_response = np.exp(-np.arange(n_time)\\/float(tau))\\nimpulse_response \\/= impulse_response.sum()\\n\\nlatents = np.array([np.convolve(e, impulse_response, mode='full')[:n_time] for e in events])\\navg_latent = np.convolve(avg_event, impulse_response, mode='full')[:n_time]\\n\\n# Coupling from one dimensional latent state to each neuron\\nreadout_weights = np.random.rand(n_neuron) + 0.1\\n\\n# Probability of firing for each neuron\\nrates = np.exp(np.array([np.outer(latent, readout_weights) for latent in latents]))\\nrates -= rates.min()#(0, 1), keepdims=True)\\nrates \\/= rates.max()#0,1), keepdims=True)\\n\\n# Sample spike trains\\nspikes = np.random.binomial(1, rates).astype(np.float32)\\n\\n# Mark end of last few trials as missing data to demonstrate that twPCA works with variable-length data\\nspikes[80:, 115:] = np.nan\\n\\nfigure(figsize=(10,3))\\nsubplot(121)\\nimshow(rates[..., 0], aspect='auto', cmap=cm.viridis); colorbar()\\ntitle('Firing rate for neuron 1')\\nxlabel('Time')\\nylabel('Trial')\\nsubplot(122)\\nimshow(spikes[..., 0], aspect='auto', cmap=cm.viridis); colorbar()\\ntitle('Spikes for neuron 1')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nGenerate synthetic data\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"(Optional) Build the ML container image\\nThis is the TFX runtime environment for the training pipeline steps.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n!echo $TFX_IMAGE_URI\\n\\n!gcloud builds submit --tag $TFX_IMAGE_URI . --timeout=15m --machine-type=e2-highcpu-8\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Creating cells\\nTo create a new code cell, click \\\"Insert > Insert Cell [Above or Below]\\\". A code cell will automatically be created.\\nTo create a new markdown cell, first follow the process above to create a code cell, then change the type from \\\"Code\\\" to \\\"Markdown\\\" using the dropdown next to the run, stop, and restart buttons.\\nRe-running cells\\nIf you find a bug in your code, you can always update the cell and re-run it. However, any cells that come afterward won't be automatically updated. Try it out below. First run each of the three cells. The first two don't have any output, but you will be able to tell they've run because a number will appear next to them, for example, \\\"In [5]\\\". The third cell should output the message \\\"Intro to Data Analysis is awesome!\\\"\\n\",\"targets\":\"class_name = \\\"Intro to Data Analysis\\\"\\n\\nmessage = class_name + \\\" is awesome!\\\"\\n\\nmessage\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"05_devel\\/bigquery_cloud_client.ipynb\\\".\\nThe first task is:\\nAnother way is to create a dataset reference\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom google.cloud.bigquery.dataset import DatasetReference\\ndsinfo = bq.get_dataset('bigquery-public-data.london_bicycles')\\nprint('{} created on {} in {}'.format(dsinfo.dataset_id, dsinfo.created, dsinfo.location))\\nfor access in dsinfo.access_entries:\\n if access.role == 'READER':\\n print(access)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Congratulations! You just created your first tasking order to the Planet Tasking API. Depending on the start and end time that you provided, a satellite will be attempting to take an image over your given coordinates in the near future.\\n2 | Check the status of the tasking order\\nTo see the status an existing tasking order, the tasking order id is required. Depending on the tasking order, it can take some time for the status of the tasking order to change, and so you may need to come back to this section once some time has elapsed before changes to the tasking order can be seen. It is recommended to run the next part of this notebook to extract the ID of the newly created order and save that for later use.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Get the response JSON and extract the ID of the order\\nresponse = res.json()\\nnew_order_id = response[\\\"id\\\"]\\np(new_order_id)\\n\\ndef check_order_status(order_id):\\n # Make a GET request with the order_id concatenated to the end of the \\/orders url; e.g. https:\\/\\/api.planet.com\\/tasking\\/v2\\/orders\\/\\n res = session.request('GET', TASKING_API_URL + '\\/orders\\/' + order_id)\\n\\n if res.status_code == 403:\\n print('Your PLANET_API_KEYPLANET_API_KEY is valid, but you are not authorized to view this order.')\\n elif res.status_code == 401:\\n print('Your PLANET_API_KEYPLANET_API_KEY is incorrect')\\n elif res.status_code == 404:\\n print(f'Your order ({order_id}) does not exist')\\n elif res.status_code != 200:\\n print(f'Received status code {res.status_code} from the API. Please contact support.')\\n else:\\n order = res.json()\\n p(res.json())\\n print(f'Your order is {order[\\\"status\\\"]} with {order[\\\"capture_status_published_count\\\"]} published captures '\\n f'and {order[\\\"capture_assessment_success_count\\\"]} successful captures')\\n\\ncheck_order_status(new_order_id)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Adding image files\\nExisting images (e.g., photos, screenshots, sketches etc.) can be added\\nto the report via :meth:mne.Report.add_image. Supported image formats\\ninclude JPEG, PNG, GIF, and SVG (and possibly others). Like with Matplotlib\\nfigures, you can specify a caption to appear below the image.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nreport = mne.Report(title='Image example')\\nreport.add_image(\\n image=mne_logo_path, title='MNE',\\n caption='Powered by 🧠 🧠 🧠 around the world!'\\n)\\nreport.save('report_custom_image.html', overwrite=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Custom training: walkthrough\\n\\n \\n View on TensorFlow.org<\\/a>\\n <\\/td>\\n \\n Run in Google Colab<\\/a>\\n <\\/td>\\n \\n View source on GitHub<\\/a>\\n <\\/td>\\n \\n Download notebook<\\/a>\\n <\\/td>\\n<\\/table>\\n\\nThis tutorial shows you how to train a machine learning model with a custom training loop to categorize penguins by species. In this notebook, you use TensorFlow to accomplish the following:\\n\\nImport a dataset\\nBuild a simple linear model\\nTrain the model\\nEvaluate the model's effectiveness\\nUse the trained model to make predictions\\n\\nTensorFlow programming\\nThis tutorial demonstrates the following TensorFlow programming tasks:\\n\\nImporting data with the TensorFlow Datasets API\\nBuilding models and layers with the Keras API\\n\\nPenguin classification problem\\nImagine you are an ornithologist seeking an automated way to categorize each penguin you find. Machine learning provides many algorithms to classify penguins statistically. For instance, a sophisticated machine learning program could classify penguins based on photographs. The model you build in this tutorial is a little simpler. It classifies penguins based on their body weight, flipper length, and beaks, specifically the...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n!pip install -q tfds-nightly\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"As a quick example, let's wrap bash's ls with Nipype:\\n\",\"targets\":\"nipype_ls = CommandLine('ls', args='-lh', terminal_output='allatonce')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"1j_NLP_Python\\/ex02.ipynb\\\".\\nThe first task is:\\nHowever, one can normalize then encode…\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport unicodedata\\n# NFKD a robust way to handle normalizers - convert special characters into something\\n# that can be read and convert into ascii\\nunicodedata.normalize('NFKD', x).encode('ascii','ignore')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2016-2017.Meetings\\/fall\\/05.DIY_naive_bayes\\/naive_bayes_classifier_solution\\/naive_bayes_tweet_classifier.ipynb\\\".\\nThe first task is:\\nLet's take a look at our output \\/ a bit of our output for the long dictionaries\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntotal_tweet_count\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"- Linear Predictor\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntic = time()\\n\\nfrom predictor.linear_predictor import LinearPredictor\\nPREDICTOR_NAME = 'linear'\\n\\n# Global variables\\neval_predictor = LinearPredictor()\\nstep_eval_days = 60 # The step to move between training\\/validation pairs\\nparams = {'eval_predictor': eval_predictor, 'step_eval_days': step_eval_days}\\n\\nresults_df = misc.parallelize_dataframe(params_list_df, misc.apply_mean_score_eval, params)\\n\\nresults_df['r2'] = results_df.apply(lambda x: x['scores'][0], axis=1)\\nresults_df['mre'] = results_df.apply(lambda x: x['scores'][1], axis=1)\\n# Pickle that!\\nresults_df.to_pickle('..\\/..\\/data\\/results_ahead{}_{}_df.pkl'.format(AHEAD_DAYS, PREDICTOR_NAME))\\nresults_df['mre'].plot()\\n\\nprint('Minimum MRE param set: \\\\n {}'.format(results_df.iloc[np.argmin(results_df['mre'])]))\\nprint('Maximum R^2 param set: \\\\n {}'.format(results_df.iloc[np.argmax(results_df['r2'])]))\\n\\ntoc = time()\\nprint('Elapsed time: {} seconds.'.format((toc-tic)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"PGM-W1\\/Factor.ipynb\\\".\\nThe first task is:\\nUnit Testing\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef compare_factors(A, B):\\n ttl_variables_A = len(A.variables)\\n map_variables = get_member_index(A.variables, B.variables)\\n \\n # Compare variables\\n if np.array_equal(A.variables, B.variables[map_variables]):\\n print(\\\"%-58s%12s\\\" % (\\\"Variables:\\\", \\\"same\\\"))\\n else:\\n print(\\\"%-58s%12s\\\" % (\\\"Variables:\\\", \\\"DIFFERENT\\\"))\\n print(\\\" A: \\\", A.variables)\\n print(\\\" B: \\\", B.variables[map_variables])\\n \\n # Compare cardinalities\\n if np.array_equal(A.cardinalities, B.cardinalities[map_variables]):\\n print(\\\"%-58s%12s\\\" % (\\\"Cardinalities:\\\", \\\"same\\\"))\\n else:\\n print(\\\"%-58s%12s\\\" % (\\\"Cardinalities:\\\", \\\"DIFFERENT\\\"))\\n print(\\\" A: \\\", A.cardinalities)\\n print(\\\" B: \\\", B.cardinalities[map_variables])\\n \\n # Compare values\\n ttl_values = np.prod(A.cardinalities)\\n cart = cartesian([range(cardinality) for cardinality in A.cardinalities])\\n for i in range(ttl_values):\\n variables_assignments = [\\\"%s=%s\\\" % (A.variables[j], cart[i][j]) for j in range(ttl_variables_A)]\\n if math.isclose(A.get_value_of_assignment(cart[i]), \\n B.get_value_of_assignment(cart[i][map_variables]),\\n rel_tol=1e-15, abs_tol=0.0):\\n print(\\\"%-58s%12s\\\" % (\\\"Values(\\\" + \\\",\\\".join(variables_assignments) + \\\"):\\\", \\\"same\\\"))\\n else:\\n print(\\\"%-58s%12s\\\" % (\\\"Values(\\\" + \\\",\\\".join(variables_assignments) + \\\"):\\\", \\\"DIFFERENT\\\"))\\n \\n print(\\\" A: \\\", A.get_value_of_assignment(cart[i]))\\n print(\\\" B: \\\", B.get_value_of_assignment(cart[i][map_variables]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Fooling Neural Networks part 2.ipynb\\\".\\nThe first task is:\\nIf you don't have the patience to sit through the retraining, the answer is: no, it doesn't misclassify this image as a 3 in the same way anymore. The image we generated above exploits the particular weights that the network developed when we first trained it, and those weights depend on particular bits of training data that we fed the network.\\nYou could use this technique for steganography—sending hidden messages—by giving a copy of your network weights to someone else and generating optimized images for it. To an outside observer (or a network with a different set of weights), these images would look like random noise, but to your friend they'd be completely decodable.\\nInterpreting a convolutional neural network\\nIt doesn't get us very far to simply generate images that optimize for a particular output: the optimized images that we've generated look like noise to us despite the fact that, to the network, they look more like a 3 than an actual 3 does.\\nThere are a few more promising methods for understanding how a more complex neural network reasons. First of all, we can look at how the convolutional layers respond when we feed in a familiar image.\\nThe first convolutional layer looks for the same 32 features over and over again in 5 x 5 pixel patches. We don't know exactly what feature it will identify when we set up the network; that's one of the mysterious patterns that the network will discover for itself.\\nLet's use a nice image of a 3 and see how the first convolutional layer responds to it. We'll iterate over the 32 features that it's learned to identify, first displaying the weights for that feature, then displaying where on the image that feature gets activated.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimage = mnist.validation.images[12].reshape([1, 784]).copy()\\n\\nw_conv1 = sess.graph.get_tensor_by_name(\\\"W_conv1:0\\\").eval({x: image, keep_prob: 1})\\nprint(w_conv1.shape)\\nh_conv1 = sess.graph.get_tensor_by_name(\\\"h_conv1:0\\\").eval({x: image, keep_prob: 1})\\nprint(h_conv1.shape)\\n\\nfor feature in range(32):\\n print(\\\"Feature:\\\", feature)\\n plt.imshow(w_conv1[:, :, 0, feature], cmap='Greys', interpolation='none')\\n plt.show()\\n plt.imshow(h_conv1[0, :, :, feature].reshape([28, 28]), cmap='Greys')\\n plt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Challenge 4: Make a function\\nTurn the code above into a function that accepts a URL, scrapes the URL for its senators, and returns a list of tuples containing information about each senator.\\n\",\"targets\":\"# YOUR FUNCTION HERE\\n\\n# Uncomment to test you3 code!\\n\\n# senateMembers = get_members('http:\\/\\/www.ilga.gov\\/senate\\/default.asp?GA=98')\\n# len(senateMembers)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"CHIMERA with solver in full PIC mode\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nxmin, xmax = -7.*Size,7.*Size\\nlrg = 30*Size\\nNx = 300\\nNr = 300\\n\\ndx = (xmax-xmin)\\/Nx\\ndr = lrg\\/Nr\\ndt = 0.06\\n\\nsolver_in1 = {\\n 'Grid':(xmin, xmax,lrg,dx,dr),'TimeStep':dt,'MaxAzimuthMode':1,\\n 'Features':('SpaceCharge',),'Xchunked':(4,6)\\n}\\n\\nbeam_in1 = {\\n 'Grid':(xmin, xmax,lrg,dx,dr),'TimeStep':dt,'Charge':-1.,'Mass':1.,\\n 'Density':nmax, 'FixedCell':(4,8,8),'MomentaMeans':(pz0,0.,0.),\\n 'Features':(),'Xchunked':(4,6)\\n}\\n\\nsolver1 = Solver(solver_in1)\\nbeam1 = Specie(beam_in1)\\n\\nMovingFrame = {'TimeStep':dt,'Steps':1,'Features':('NoSorting','Staged')}\\n\\nchimera_in1 = {\\n 'Solvers':(solver1,),'Particles':(beam1,),'MovingFrames':(MovingFrame,)\\n}\\n\\nfu = lambda x,y,z: np.exp(-0.5*(x**2+y**2+z**2)\\/Size**2)\\nbeam1.add_particles(*beam1.gen_parts(Domain=(-3.5*Size,3.5*Size, 0.0, 3.5*Size),ProfileFunc=fu))\\n\\nChimera1 = ChimeraRun(chimera_in1)\\nDiags1 = Diagnostics(Chimera1,(),out_folder=None)\\n\\nfor i in range(int(SimLgth\\/dt)+1):\\n Chimera1.make_step(i)\\n sys.stdout.write('\\\\r'+str(i)+'\\/'+str(int(SimLgth\\/dt)))\\n sys.stdout.flush()\\n\\nfig,((ax1,ax2,ax3),(ax4,ax5,ax6)) = plt.subplots(2,3,figsize=(16,12),dpi=200)\\n\\ndpmax = (beam.Data['momenta'][0].max()-pz0)*1e3\\nrange1 = [[SimLgth-10,SimLgth+10],[-2*dpmax,+2*dpmax]]\\nrange2=[[-15,15],[-2,2]]\\nweight2pC = beam.Args['weight2pC']\\n\\ndns_max = 1e-3\\n\\nax1.hist2d(beam1.Data['coords'][0],(beam1.Data['momenta'][0]-pz0)*1e3,weights=-beam1.Data['weights'],\\n bins=120,range=range1,vmax=dns_max,cmap=plt.cm.spectral);\\nax4.hist2d(beam1.Data['coords'][2],beam1.Data['momenta'][2]*1e4,weights=-beam1.Data['weights'],\\n bins=120,range=range2,vmax=dns_max,cmap=plt.cm.spectral);\\n\\nax2.hist2d(beam.Data['coords'][0],(beam.Data['momenta'][0]-pz0)*1e3,weights=-beam.Data['weights'],\\n bins=120,range=range1,vmax=dns_max,cmap=plt.cm.spectral);\\nax5.hist2d(beam.Data['coords'][2],beam.Data['momenta'][2]*1e4,weights=-beam.Data['weights'],\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!gcloud ai-platform jobs describe txtcls_190209_224828\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nChange the job name appropriately. View the job in the console, and wait until the job is complete.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Curve Fitting\\nSuppose we have data sampled from f with some noise:\\n\",\"targets\":\"xdata = np.linspace(-10, 10, num=20)\\nydata = f(xdata) + np.random.randn(xdata.size)\\nplt.plot(xdata,ydata)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A questo punto possiamo rappresentare la funzione $f(x)=x^3$ nel modo seguente:\\n\",\"targets\":\"#%matplotlib inline # Da usare sono una volta\\nX = range(-10, 11)\\nY = H(X)\\nplot(X,Y)\\ntitle(\\\"Esempio di $f(x)=x^3$, con $-10 \\\\leq x \\\\leq 10$\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\nWe will again use the \\\"RPi.GPIO\\\" library in our code\\nAnd for the GPIO pins we will, as usual, use the BCM numbering (cfr numbers on the case)\\n\",\"targets\":\"import RPi.GPIO as GPIO\\nGPIO.setmode(GPIO.BCM)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"PySAL.Network_&_Spatial_Optimization.ipynb\\\".\\nThe first task is:\\nSolutions\\nGurobi\\nCan you write Python code for it?\\n\",\"targets\":\"\\nt1 = time.time()\\n\\ngbp.setParam('MIPFocus', 2) # Set MIP focus to 'Optimal' --> 2\\n# Instantiate Optimization model from .lp file\\nGurobi_PCP = gbp.read(path+'LP_Files\\/pCenter_Manual.lp') \\n\\nGurobi_PCP.optimize()\\nt2 = time.time()-t1\\n\\n# Record and Display Results\\nprint '\\\\n*************************************************************************'\\nselected_Gurobi_PCP = []\\ndbf1 = ps.open(path+'Snapped\\/SERVICE_Snapped.dbf')\\nNEW_Records_PCP_Gurobi = []\\nfor v in Gurobi_PCP.getVars():\\n if 'x' in v.VarName:\\n pass\\n elif 'W' in v.VarName:\\n pass\\n elif v.x > 0:\\n var = '%s' % v.VarName\\n selected_Gurobi_PCP.append(var)\\n for i in range(dbf1.n_records):\\n if var in dbf1.read_record(i):\\n x = dbf1.read_record(i)\\n NEW_Records_PCP_Gurobi.append(x)\\n else:\\n pass\\n print ' | ', var\\nprint ' | Selected Facility Locations -------------- ^^^^ '\\nprint ' | Candidate Facilities [p] ----------------- ', len(selected_Gurobi_PCP)\\nprint ' | Objective Value (miles) ------------------ ', Gurobi_PCP.objVal\\nprint ' | Real Time to Optimize (sec.) ------------- ', t2\\nprint '*************************************************************************'\\nprint ' -- The p-Center Problem Gurobi -- '\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Accessing files on the internet\\nThe Python urllib2 package makes is relatively easy to access a file on the internet. See also the functions \\nryfiles.unzipGZipfile,\\nryfiles.untarTarfile, and \\nryfiles.downloadFileUrl.\\nPython functions\\n\",\"targets\":\"def square(value):\\n return value ** 2\\n\\nprint(square(5))\\nprint(square(5.))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Creando archivo rmsf.dat para su visualización en Matplotlib\\nSe genera el gráfico de salida para matplotlib\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndata_rmsf=np.loadtxt('rmsf.xvg',comments=['#', '@'])\\n\\n \\n#Engrosar marco \\nfig=pl.figure(figsize=(20, 12), dpi=100, linewidth=3.0)\\nax = fig.add_subplot(111)\\nfor axis in ['top','bottom','left','right']:\\n ax.spines[axis].set_linewidth(4)\\n\\n#Formateando los valores de los ejes\\nax.yaxis.set_major_formatter(FormatStrFormatter('%.2f'))\\n\\npl.plot(data_rmsf[:,0], data_rmsf[:,1], '-o', color='black', markersize=25,\\n markerfacecolor='red',markeredgecolor='black',markeredgewidth=3, linewidth = 4, )\\npl.xlabel(\\\"Residue\\\", fontsize = 40)\\npl.ylabel('RMSF (nm)', fontsize = 40)\\n#pl.title('RMSF Fluctuation', fontsize=40)\\npl.xticks(fontsize=30) \\npl.yticks(fontsize=30) \\npl.xlim(0, len(data_rmsf[:,1]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2-AnalyseDuTitanic.ipynb\\\".\\nThe first task is:\\nTraitement de données classique\\nNous allons voir dans cet exemple comment utiliser la bibliothèque numpy pour récupérer des valeurs dans un fichier csv et commencer à les traiter.\\nNous allons utiliser le module csv qui permet de lire un fichier csv et d'en extraire les valeurs lignes par lignes.\\nNous allons travailler sur le fichier de données d'entraînement du Titanic. Le but est de prédire les chance de survie à bord du bateau. Il faut récupérer le fichier train.csv (voir le premier cours ou téléchargez le depuis https:\\/\\/www.kaggle.com\\/c\\/titanic-gettingStarted\\/data ) et le sauvegarder dans le répertoire dans lequel le notebook s'éxecute. Vous pouvez utiliser la commande pwd pour connaître ce répertoire. Sinon, vous pouvez déplacer le répertoire courant pour rejoindre l'endroit où vous avez sauvegardé votre fichier avec la commande cd.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport csv\\nimport numpy as np\\n\\nfichier_csv = csv.reader(open('train.csv', 'r'))\\nentetes = fichier_csv.__next__() # on récupère la première ligne qui contient les entetes\\ndonnees = list() # on crée la liste qui va servir à récupérer les données\\n\\nfor ligne in fichier_csv: # pour chaque ligne lue dans le fichier csv\\n donnees.append(ligne) # on ajoute les valeurs lues dans le tableau donness\\n#entete = donnees[0]\\n#donnees[0] = []\\ndonnees = np.array(donnees) # le tableau donnees est transformé en numpy array\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Data_analysis\\/SNP-indel-calling\\/dadi\\/03_1D_bottlegrowth.ipynb\\\".\\nThe first task is:\\nWhat were the initial parameter values for unsuccessful optimisations?\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfor out in ar_ery:\\n if out[1][4] == 0: \\n continue\\n print out[0]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1.2 Training the ML algorithm\\nNLTK module is built for working with language data. NLTK supports classification, tokenization, stemming, tagging, parsing, and semantic reasoning functionalities. We will use the NLTK module and employ the naive Bayes method to classify words as being either positive or negative sentiment. You can also use other modules specifically meant for ML eg. sklearn module.\\nStep 1: Create the feature set\\nWe will use the corpus of sentiments from the word_sentiment.csv file to create a feature dataset which we will use to train and test the ML model.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport csv\\n\\ndef feature_extractor(word):\\n \\\"\\\"\\\"Extract the features for a given word and return a dictonary of the features\\\"\\\"\\\"\\n start_letter = word[0]\\n last_letter = word[-1]\\n return {'start_letter' : start_letter,'last_letter' : last_letter}\\n\\ndef ML_train(sentiment_corpus):\\n \\\"\\\"\\\"Create feature set from the corpus given to to it.\\\"\\\"\\\"\\n feature_set = []\\n with open(sentiment_corpus,'rt',encoding = 'utf-8') as sentobj:\\n sentiment_handle = csv.reader(sentobj)\\n \\n for sentiment in sentiment_handle:\\n new_row = []\\n new_row.append(feature_extractor(sentiment[0])) #get the dictionary of features for a word\\n if int(sentiment[1]) >= 0: # Club the sentiment values (-5 to + 5) to just positive or negative\\n new_row.append('positive')\\n else:\\n new_row.append('negative')\\n feature_set.append(new_row)\\n print(feature_set)\\n\\ndef main():\\n sentiment_csv = \\\"C:\\/Users\\/kmpoo\\/Dropbox\\/HEC\\/Teaching\\/Python for PhD Mar 2018\\/python4phd\\/Session 3\\/Sent\\/word_sentiment.csv\\\"\\n ML_train(sentiment_csv)\\n \\nmain()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Load the MovieLens 100K data.\\nratings = tfds.load(\\n \\\"movielens\\/100k-ratings\\\",\\n split=\\\"train\\\"\\n)\\n\\n# Get the ratings data.\\nratings = (ratings\\n # Retain only the fields we need.\\n .map(lambda x: {\\\"user_id\\\": x[\\\"user_id\\\"], \\\"movie_title\\\": x[\\\"movie_title\\\"]})\\n # Cache for efficiency.\\n .cache(tempfile.NamedTemporaryFile().name)\\n)\\n\\n# Get the movies data.\\nmovies = tfds.load(\\\"movielens\\/100k-movies\\\", split=\\\"train\\\")\\nmovies = (movies\\n # Retain only the fields we need.\\n .map(lambda x: x[\\\"movie_title\\\"])\\n # Cache for efficiency.\\n .cache(tempfile.NamedTemporaryFile().name))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAnd load the data:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!pip install tensorflow==2.4.1\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n你好，量子世界\\n\\n 在 TensorFlow.org 上查看<\\/a><\\/td>\\n 在 Google Colab 中运行<\\/a><\\/td>\\n 在 GitHub 上查看源代码<\\/a><\\/td>\\n 下载笔记本<\\/a><\\/td>\\n<\\/table>\\n\\n本教程介绍经典神经网络如何学习纠正量子位校准误差。其中介绍了 Cirq<\\/a>（一个用于创建、编辑和调用嘈杂中型量子 (NISQ) 电路的 Python 框架），并演示了 Cirq 如何通过接口与 TensorFlow Quantum 连接。\\n设置\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# define header and table format (as csv)\\nhdr = (\\\"name\\\", \\\"wavelength units\\\", \\\"index units\\\", \\\"min\\\", \\\"max\\\" \\\"min blue\\\", \\\"max blue\\\", \\\"min red\\\", \\\"max red\\\")\\nfmt = \\\"{0:s},{1:s},{2:s},{3:.3f},{4:.3f},{5:.3f},{6:.5f},{7:.3f},{8:.3f}\\\\n\\\"\\n\\nl = pyphot.LickLibrary()\\n\\nwith open('licks_table.csv', 'w') as output:\\n output.write(','.join(hdr) + '\\\\n')\\n\\n for k in sorted(l.content):\\n fk = l[k]\\n # wavelength have units\\n band = fk.band.magnitude\\n blue = fk.blue.magnitude\\n red = fk.red.magnitude\\n rec = (fk.name, fk.wavelength_unit, fk.index_unit, band[0], band[1],\\n blue[0], blue[1], red[0], red[1])\\n output.write(fmt.format(*rec))\\n\\nimport pandas as pd\\ndf = pd.read_csv('.\\/licks_table.csv', index_col=False)\\ndf.head()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSimilarly, we show the content of the provided library with respective properties of the passband filters. \\nThe table below is also part of the documentation.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And plot the new results:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfig = plt.figure(figsize=(14, 7))\\nax1 = fig.add_subplot(111)\\ncont = ax1.contourf(X,Z,u_DRP.data[0,:,:], levels, cmap=cm.binary)\\nfig.colorbar(cont)\\nax1.axis([0, Lx, 0, Lz])\\nax1.set_xlabel('$x$')\\nax1.set_ylabel('$z$')\\nax1.set_title('$u_{DRP}(x,z,500)$')\\n\\nplt.gca().invert_yaxis()\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"2D Buffers vs Samples\\n\",\"targets\":\"chan6 = AlazarChannel(myctrl, 'mybufvssamples', demod=False, average_buffers=False, integrate_samples=False)\\nchan6.buffers_per_acquisition(100)\\nchan6.num_averages(100)\\nchan6.alazar_channel('A')\\nchan6.prepare_channel()\\n# Measure this \\ndata6 = qc.Measure(chan6.data).run()\\nplot = qc.MatPlot(data6.my_controller_mybufvssamples_data)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\n\\nIntroducción\\nEn el siguiente notebook se estudia la resolución numérica de ecuaciones diferenciales parciales elípticas. La resolución de estas tiene gran importancia, ya que aparecen repetidas veces en diferentes modelos físicos relacionados con los potenciales de energía. Por ejemplo, el potencial de carga eléctrica de acuerdo a las ecuaciones de Maxwell puede ser escrito como:\\n$$\\n\\\\Delta u = -\\\\frac{\\\\rho}{\\\\epsilon},\\n$$\\ncon $u$ el potencial eléctrico, $\\\\rho$ la densidad de carga, y $\\\\epsilon$ el la permitividad eléctrica.\\nEl método numérico que estudiaremos se basa en diferencias finitas, del mismo modo en que se hizo para resolver EDOs anteriormente, esto es, las derivadas son aproximadas por gradientes calculados numéricamente en base a los valores vecinos de cada punto. Sin embargo ahora las derivadas son parciales!, pero como veremos esto no es gran problema.\\n\\n\\nMarco Teórico\\nSi consideramos una función $u(x,y)$ dos veces diferenciable, entonces se define el operador Laplaciano como:\\n$$\\n\\\\Delta u(x,y) = u_{xx}(x,y) + u_{yy}(x,y),\\n$$\\nsi se considera además una función $f(x,y)$, entonces es posible definir:\\n$$\\n\\\\Delta u(x,y) = u_{xx}(x,y) + u_{yy}(x,y) = f(x,y), \\\\ \\\\ \\\\ \\\\text{con } \\\\ x,y \\\\in \\\\Omega \\\\ \\\\text{ y condiciones de borde en } \\\\ \\\\partial \\\\Omega\\n$$\\ncomo la ecuación de Poisson, la cual es una de las más conocidas dentro de la clase _ Elípticas _. El caso particular donde $f(x,y) = 0$ se conoce como ecuación de Laplace.\\nFormulación numérica\\nSea la ecuación de Laplace $\\\\Delta u(x,y) = 0$ sobre un dominio rectangular $[x_a, x_b] \\\\times [y_a, y_b]$, con condiciones de borde de Dirichlet:\\n\\\\begin{align}\\n u(x,y_a) &= g_1(x) \\\\\\n u(x,y_b) &= g_2(x) \\\\\\n u(x_a,y) &= g_3(y) \\\\\\n u(x_b,y) &= g_4(y) .\\n\\\\end{align}\\nPara resolver este problema por diferencias finitas, es necesario discretizar el dominio $\\\\Omega$ sobre el que se define la función. Tal discretización se puede ver gráficamente como se muestra a continuación:\\n\",\"targets\":\"x = np.linspace(0., 1., 10)\\ny = np.linspace(0., 1., 10)\\nxgrid, ygrid = np.meshgrid(x, y, sparse=False)\\nplt.figure(figsize=(8,8))\\nplt.scatter(xgrid.ravel(), ygrid.ravel())\\nplt.plot((0,1),(0,0), 'g--' ,lw=2)\\nplt.plot((1,1),(0,1), 'g--' ,lw=2)\\nplt.plot((1,0),(1,1), 'g--' ,lw=2)\\nplt.plot((0,0),(1,0), 'g--' ,lw=2)\\nplt.title('Esquema de discretizacion uniforme')\\nplt.xlim(-0.1,1.1)\\nplt.ylim(-0.1,1.1)\\nplt.axis('equal')\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Appendix: Our own data download and preparation\\nWe'll use the Large Movie Review Dataset v1.0 for our corpus. While Keras has its own data samples you can import for modeling (including this one), I think it's very important to get and process your own data. Otherwise, the results appear to materialize out of thin air and it's more difficult to get on with your own research.\\n\",\"targets\":\"%matplotlib inline\\nimport pandas as pd\\n\\nimport glob\\n\\ndatapath = \\\"\\/Users\\/pfigliozzi\\/aclImdb\\/train\\/unsup\\\"\\nfiles = glob.glob(datapath+\\\"\\/*.txt\\\")[:1000] #first 1000 (there are 50k)\\n\\ndf = pd.concat([pd.read_table(filename, header=None, names=['raw']) for filename in files], ignore_index=True) \\n\\ndf.raw.map(lambda x: len(x)).plot.hist()\\n\\n50000. * 2000. \\/ 10**6\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"After running the cell above you should have noticed a new browser window popping up displaying our plot. Once you are done playing with it you can stop it with:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nserver.stop()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#feature selection\\nfeats_25 = SelectPercentile(chi2, 25).fit(xtrain, y)\\nxtrain = feats_25.transform(xtrain)\\nxtest = feats_25.transform(xtest)\\n\\nclf = xgb.XGBClassifier(objective = 'binary:logistic',\\n learning_rate = 0.05,\\n max_depth = 5,\\n nthread = 8,\\n seed = 42,\\n subsample = 0.4,\\n colsample_bytree = 0.7,\\n min_child_weight = 1,\\n n_estimators = 100,\\n gamma = 0.15, silent = True)\\n\\n#bag of 15 models\\nrounds = 15\\npreds_mat = np.zeros((len(sample.index), rounds))\\nfor i in range(rounds):\\n clf.set_params(seed = i + 1)\\n clf.fit(xtrain, y)\\n preds_tmp = clf.predict_proba(xtest)[:, 1]\\n preds_mat[:, i] = preds_tmp\\nbagged_preds = preds_mat.mean(axis = 1)\\nsample.prediction = bagged_preds\\nsample.to_csv('submissions\\/facebook_submission.csv', index = False)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nModel\\nFor the final model, we perform a univariate chi2-feature selection to choose the top-25% of features. Then we fit 15 XGBoost-models to the data, where the only difference between the bagged models is the random seed. For the final submission, we take the average of the 15 models in the bag.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"4.3.3. Pandas: Parsing Timestamps\\nUnix time tracks the progress of time by counting the number of seconds since an arbitrary date, 1970-01-01 00:00, as per the UTC time zone. Generic data type is datatime64[ns]. \\npandas.to_datetime() function parses timestamps. Now it we can filter information on dates, sort dates,\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntags['parsed_time'] = pd.to_datetime(tags['timestamp'], unit = 's')\\ntags.head()\\n\\ntags[tags['parsed_time'] > '2015-02-01'].head()\\n\\ntags.sort_values(by = 'parsed_time', ascending = True)[:10]\\n\\ntags.dtypes\\n\\ntags['parsed_time'].dtype\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Load train data\\n# Given size of training data, I chose to use only 10% for speed reasons\\n# QUESTION - how can i randomize with python? i used sql to create the random sample below.\\ndf_train = pd.read_csv(\\\"..\\/train_random10percent.csv\\\")\\n\\n# Check head\\ndf_train.head()\\n\\n# Load test data\\ndf_test = pd.read_csv(\\\"..\\/test.csv\\\")\\n\\n# Check head. I noticed that I will have to drop certain columns so that test and train sets have the same features. \\ndf_test.head()\\n\\n#given that i cannot use a significant amount of variables in train data, i created additoinal features using the mean\\n#i grouped on product id since i will ultimately be predicting demand for each product\\n\\ndf_train_mean = df_train.groupby('Producto_ID').mean().add_suffix('_mean').reset_index()\\ndf_train_mean.head()\\n\\n#from above, adding 2 additional features, the average sales units and the average demand\\ndf_train2 = df_train.merge(df_train_mean[['Producto_ID','Venta_uni_hoy_mean', 'Demanda_uni_equil_mean']],how='inner',on='Producto_ID')\\ndf_train2.sample(5)\\n\\n# Adding features to the test set in order to match train set\\ndf_test2 = df_test.merge(df_train_mean[['Producto_ID','Venta_uni_hoy_mean', 'Demanda_uni_equil_mean']],how='left',on='Producto_ID')\\ndf_test2.head()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPart 1. Identify the Problem\\nProblem: Given various sales\\/client\\/product data, we want to predict demand for each product at each store on a weekly basis. Per the train dataset, the average demand for a product at a store per week is 7.2 units. However, this does not factor in cases in which store managers under-predict demand for a product which we can see when returns=0 for that week. There are 74,180,464 records in the train data, of which 71,636,003 records have returns=0 or approx 96%. This generally means that managers probably often under predict product demand (unless that are exact on the money, which seems unlikely). \\nGoals: The goal is to predict demand for each product at each store on a weekly basis while avoiding under-predicting demand.\\nHypothesis: As stated previously, the average product demand at a store per week is 7.2 units per the train data. However, given the likelihood of managers underpredicint product demand, I hypothesize a good model should return a number higher than 7.2 units to more accurately predict demand.\\n\\nPart 2. Acquire the Data\\nKaggle has provided five files for this dataset:\\ntrain.csv: Use for building a model (contains target variable \\\"Demanda_uni_equil\\\")\\ntest.csv: Use for submission file (fill in for target variable \\\"Demanda_uni_equil\\\")\\ncliente_tabla.csv: Contains client names (can be joined with train\\/test on Cliente_ID)\\nproducto_tabla.csv: Contains product names (can be join with train\\/test on Producto_ID)\\ntown_state.csv: Contains town and state (can be join with train\\/test on Agencia_ID)\\nNotes: I will further split train.csv to generate my own cross validation set. However, I will use all of train.csv to train my final model since Kaggle has already supplied a test dataset. Additionally, I am only using a random 10% of the train data given to me for EDA and model development. Using the entire train dataset proved to be too time consuming for the quick iternations needed for initial modeling building and EDA efforts. I plan to use 100% of the train dataset once I...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\n EJERCICIO<\\/b>:\\n \\n \\n **Cambia** el parámetro `gamma` y comprueba como afecta la función de decisión.\\n <\\/li>\\n <\\/ul>\\n<\\/div>\\n\\nIsolation Forest\\nEl algoritmo Isolation Forest es un algoritmo de AD basado en árboles. Construye un determinado número de árboles aleatorios y su idea principal es que si un ejemplo es una anomalía, entonces debería aparecer aislado en la hoja de un árbol tras algunas particiones. El Isolation Forest deriva una puntuación de anormalidad basada en la profundidad del árbol en la cuál términos los ejemplos anómalos.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.ensemble import IsolationForest\\n\\niforest = IsolationForest(n_estimators=300, contamination=0.10)\\niforest = iforest.fit(X)\\n\\nfrom scipy.stats import scoreatpercentile\\n\\nZ_iforest = iforest.decision_function(grid)\\nZ_iforest = Z_iforest.reshape(xx.shape)\\n\\nthreshold = -scoreatpercentile(-iforest.decision_function(X), 100. * (1. - iforest.contamination))\\n\\nplt.figure()\\nc_0 = plt.contour(xx, yy, Z_iforest,\\n levels=[threshold],\\n colors='red', linewidths=3)\\nplt.clabel(c_0, inline=1, fontsize=15,\\n fmt={threshold: str(alpha_set)})\\nplt.scatter(X[:, 0], X[:, 1], s=1.)\\nplt.legend()\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Just looking at color, size & price we can convert non numeric data with\\n# the LabelEncoder\\n\\nX = df[['color', 'size', 'price']].values\\n\\ncolor_le = LabelEncoder()\\nX[:, 0] = color_le.fit_transform(X[:, 0])\\nX\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n \\n \\nPerforming one-hot encoding on nominal features\\nConvert categorical variable(s) into dummy\\/indicator variables\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Python 2 and 3: option 1\\nitemlist = list(heights.items()) # inefficient on Py2\\n\\n# Python 2 and 3: option 2\\nfrom future.utils import listitems\\n\\nitemlist = listitems(heights)\\n\\n# Python 2 and 3: option 3\\nfrom future.utils import iteritems\\n# or\\nfrom six import iteritems\\n\\nitemlist = list(iteritems(heights))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\ndict items as a list:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Data_Types_Control_Flow_Operators.ipynb\\\".\\nThe first task is:\\nThere can be no elif and the final else is optional. \\nNote for people with a different language background, Python doesn't have a switch or case statement\\nFor\\nPython iterates over items of any sequence\\nCan you write Python code for it?\\n\",\"targets\":\"\\nwords = ['cat', 'dog', 'alligator', 'pirate']\\nfor w in words:\\n print(w, len(w))\\n\\nvar1 = \\\"this is sstring\\\"\\nfor char in var1:\\n print(hex(ord(char)))\\n\\nhelp(ord)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\" Color cubes\\nVolume rendering lets you render a sequence of images as a 3D volume.\\n \\nLightining currently assumes isotropic images, so the sampling in x,y, and z should be comparable.\\n \\nVisualizing color spaces is a fun way to explore volume rendering. We'll generate RGB and HSV cubes.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnx, ny, nz = (50, 50, 50)\\nrgb = ndarray((nx,ny,nz,3))\\nhsv = ndarray((nx,ny,nz,3))\\nfor i, ii in enumerate(linspace(0,1,nx)):\\n for j, jj in enumerate(linspace(0,1,ny)):\\n for k, kk in enumerate(linspace(0,1,nz)):\\n position = (i, j, k)\\n rgb[position] = (kk, jj, ii)\\n hsv[position] = hsv_to_rgb(jj, ii, kk)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"1. Generate simulated data for both settings\\n\",\"targets\":\"def simulate_s(n):\\n \\\"\\\"\\\"\\n Simulates data with different mean but same variance\\n \\n inp:\\n @n: number of samples\\n outp:\\n @A: data vector\\n @y: true labels\\n \\\"\\\"\\\"\\n A = np.random.random(n)\\n A[int(n\\/2):] += 4\\n\\n y = np.repeat(0, n)\\n y[int(n\\/2):] += 1\\n return (A, y)\\n\\ndef simulate_f(n):\\n \\\"\\\"\\\"\\n Simulates data with same mean but different variance\\n \\n inp:\\n @n: number of samples\\n outp:\\n @A: data vector\\n @y: true labels\\n \\\"\\\"\\\"\\n A = np.append(np.random.random(int(np.floor(n\\/2)))*10-5, np.random.random(int(np.ceil(n\\/2)))*2-1)\\n\\n y = np.repeat(0, n)\\n y[int(np.ceil(n\\/2)):] += 1\\n return (A, y)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"4.Schreibe eine Funktion, die einen String nimmt, und spiegelt. Also \\\"hallo\\\" zu \\\"ollah\\\".\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nspruch = \\\"hallo\\\"\\n\\ndef mirror(mylist):\\n for elem in mylist:\\n return mylist[::-1]\\n\\nmirror(spruch)\\n\\n5.Schreibe eine Funktion, die prüft, ob eine Zahl in einer bestimmten Zahlenfolge zu finden ist.\\n\\nliste = [45, 34, 64, 45]\\n\\ndef searchnbr(mylist):\\n if 56 in mylist:\\n return \\\"Treffer\\\"\\n else: \\n return \\\"Kein Treffer\\\"\\n\\nsearchnbr(liste)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"As in the existing interface, variables can be keys to the data object or vectors of various kinds:\\n\",\"targets\":\"(\\n so.Plot(tips.to_dict(), x=\\\"total_bill\\\")\\n .add(so.Scatter(), y=tips[\\\"tip\\\"].to_numpy())\\n)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Class attributes\\n\\ndata attributes: these correspond to data members in C++\\nmethods: these correspond to methods in C++\\n\\nboth are\\n\\ncreated upon assignment\\ncan be assigned anywhere (not just in __init__)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nclass A:\\n def __init__(self):\\n self.attr1 = 42\\n \\n def method(self):\\n self.attr2 = 43\\n \\na = A()\\nprint(a.attr1)\\n# print(a.attr2) # raises AttributeError\\na.method()\\nprint(a.attr2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"10-Metadata\\/02-HTRC-Classification-Example.ipynb\\\".\\nThe first task is:\\nWe can also get the most helpful features, or words, for each class. First we'll fit the model:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmodel.fit(X, y)\\n\\nfeats = np.argsort(model.coef_[0])[:50]\\ntop_scifi = [(list(feats).index(wordDict[w]) + 1, w) for w in wordDict.keys() if wordDict[w] in feats]\\nsorted(top_scifi)\\n\\nfeats = np.argsort(model.coef_[0])[-50:]\\ntop_poetry = [(list(feats).index(wordDict[w]) + 1, w) for w in wordDict.keys() if wordDict[w] in feats]\\nsorted(top_poetry, key=lambda tup: tup[0])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Proof of concept minimise cold probability.ipynb\\\".\\nThe first task is:\\nCreate the PDF for exposure given a distance and uncertainty\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnum_relevant_dwells = np.sum(is_dwell_closest_to_target)\\n\\ndef create_pdf_given_time(exposure, distance, uncertainty): \\n exposure = np.reshape(exposure, [1, 1, -1])\\n distance = np.expand_dims(distance, axis=2)\\n uncertainty = np.expand_dims(uncertainty, axis=2) \\n \\n bot = 2*np.sqrt(2 * np.pi) * uncertainty * exposure**1.5\\n \\n def pdf(time):\\n time = np.reshape(time, [1, -1, 1])\\n top = (\\n np.sqrt(time) * \\n np.exp(\\n -(np.sqrt(time\\/exposure) - distance)**2 \\/ \\n (2*uncertainty**2)))\\n \\n return top\\/bot\\n \\n return pdf\\n\\nn = 2**9\\nexposure_spacing = np.linspace(0.01, 100, n)\\npdf = create_pdf_given_time(exposure_spacing, distance_to_dwell_pos, dwell_distance_uncertainty)\\n\\ntime = np.ones(num_relevant_dwells)\\n\\ncheck = pdf(time)\\n\\n\\n\\nfor i in range(num_relevant_dwells):\\n plt.plot(exposure_spacing, check[6,i,:])\\n plt.ylim([0, 0.4])\\n\\nnp.shape(check[0,:,:])\\n\\nfft_of_rows = np.fft.rfft(check[2,:,:])\\nfft_of_convolution = fft_of_rows.prod(axis=0)\\nconvolution_not_normalised = np.fft.irfft(fft_of_convolution)\\n# convolution = convolution_not_normalised[0:n] \\/ np.trapz(convolution_not_normalised[0:n], x=exposure_spacing)\\n\\n# plt.plot(exposure_spacing, convolution)\\n\\nplt.plot(exposure_spacing, convolution_not_normalised)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Db2 Compatibility Features.ipynb\\\".\\nThe first task is:\\nSTRRIGHT is an alias for RIGHT\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%%sql\\nVALUES ('RIGHT',RIGHT('Hello There',5))\\nUNION ALL\\nVALUES ('STRRIGHT',STRRIGHT('Hello There',5))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And here's the figure from the book.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsubplot(3, 1, 1)\\nplot(thetas, label='theta')\\ndecorate(ylabel='Angle (rad)')\\n\\nsubplot(3, 1, 2)\\nplot(ys, color='green', label='y')\\ndecorate(ylabel='Length (m)')\\n\\nsubplot(3, 1, 3)\\nplot(rs, color='red', label='r')\\n\\ndecorate(xlabel='Time(s)',\\n ylabel='Radius (mm)')\\n\\nsavefig('chap11-fig01.pdf')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And now for some landform evolution. We will loop through 25 iterations, representing 50,000 years. On each pass through the loop, we do the following:\\n\\n\\nCalculate, and store in the array g, the gradient between each neighboring pair of nodes. These calculations are done on links. The gradient value is a positive number when the gradient is \\\"uphill\\\" in the direction of the link, and negative when the gradient is \\\"downhill\\\" in the direction of the link. On a raster grid, link directions are always in the direction of increasing $x$ (\\\"horizontal\\\" links) or increasing $y$ (\\\"vertical\\\" links).\\n\\n\\nCalculate, and store in the array qs, the sediment flux between each adjacent pair of nodes by multiplying their gradient by the transport coefficient. We will only do this for the active links (those not connected to a closed boundary, and not connecting two boundary nodes of any type); others will remain as zero.\\n\\n\\nCalculate the resulting net flux at each node (positive=net outflux, negative=net influx). The negative of this array is the rate of change of elevation at each (core) node, so store it in a node array called `dzdt'.\\n\\n\\nUpdate the elevations for the new time step.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfor i in range(25):\\n g = mg.calc_grad_at_link(z)\\n qs[mg.active_links] = -D * g[mg.active_links]\\n dzdt = -mg.calc_flux_div_at_node(qs)\\n z[mg.core_nodes] += dzdt[mg.core_nodes] * dt\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"2.2. Lorentzian distribution\\n\",\"targets\":\"# LORENTZIAN GRAPHICS\\ngamma = 100 # Lorentzian standard deviation.\\nwide = 400 # Slide wide.\\nxia = np.linspace(-wide, wide, 100)\\nlorentz_coherence = lambda x: CoherenceDegree.lorentz_coherence(x, gamma)\\n\\nplt.plot(xia, gauss_coherence(xia))\\nplt.xlabel(r'$\\\\xi_A \\\\ [\\\\mu m]$')\\nplt.ylabel(r'$Intensity \\\\ I(\\\\xi_A)$')\\nplt.title(r'$ LORENTZIAN $')\\nplt.axis([-wide, wide, -0.2, 1.3])\\nplt.grid(True)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#export\\nfrom modsim import decorate\\n\\ndef plot_results(S, I, R):\\n S.plot(style='--', label='Susceptible')\\n I.plot(style='-', label='Infected')\\n R.plot(style=':', label='Resistant')\\n decorate(xlabel='Time (days)',\\n ylabel='Fraction of population')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe'll use the following function to plot the results:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Python.ipynb\\\".\\nThe first task is:\\nMetode\\nFunctiile sunt secvente de cod, apelate prin NumeFunctie(argumente). Metodele sunt functii asociate unui obiect, in acest caz unei liste. \\nO metoda pentru liste se apeleaza astfel:\\nNumeLista.NumeMetoda(argumente)\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#L.append(elem) adauga elementul elem la lista\\n\\nL=[4,5,2,7]\\nL.append(2)\\nprint L\\n\\n# nr=L.count(elem) este numarul de cate ori elementul elem apare in lista\\nL=[0, 1, 2, 3 ,4, 5, 6,5]\\nnr=L.count(5)\\nprint '5 apare de ', nr, 'ori'\\n\\n# L.index(elem)indica primul indice la care apare elementul elem in lista\\nL=[-2, 1, 7, 3, 7]\\npind=L.index(7)\\nprint pind\\n\\n\\nprint L\\n# L.insert(i,elem) insereaza elementul elem in pozitia L[i] \\n#si deplaseaza elementele din dreapta cu o pozitie\\nL.insert(1, 10)\\nprint L\\n\\nL=[1,2,5, 3,4,6]\\n#L.remove(elem) sterge elementul elem din lista\\nL.remove(5)\\nprint L\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"BinaryDetection.ipynb\\\".\\nThe first task is:\\nNow, we repeat the excersice for $e=0.5$. As you can see the probability contours move inwards a little, but overall that is not a dramatic change.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntimes = np.arange(0.,10.,1.)\\nprop_e05 = np.zeros_like(Pgrid)\\nfor x, y in np.ndindex(Pgrid.shape):\\n prop_e05[x,y] = prob_to_detect(2.*u.km\\/u.s, times, a1grid[x,y], Pgrid[x,y], 0.5)\\n\\ncs = plt.contour(agrid, m2grid, prop_e05)\\nplt.clabel(cs)\\nplt.xlabel('Semi-major axis [AU]')\\nplt.ylabel('mass of secondary [$M_{\\\\odot}$]')\\nplt.title('Probability of detection for $e$ = 0.5')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"About_Decorators.ipynb\\\".\\nThe first task is:\\nThanks to Compose, the \\\"class decorator\\\" (a decorator that happens to be a class), our F and G are actually Compose type objects, so have this additional ability to compose into other Compose type objects. We don't need an argument until we call the final H.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nH = F*G*F*F*F*G # the functions themselves may be multiplied\\nH(10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Also, we must add a few geometrical properties that were not included in the extracted network:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npn['pore.diameter'] = 2*pn['pore.radius']\\npn['throat.diameter'] = 2*pn['throat.radius']\\npn.add_model(propname='pore.area',\\n model=op.models.geometry.pore_area.sphere)\\npn.add_model(propname='throat.area',\\n model=op.models.geometry.throat_area.cylinder)\\npn.add_model(propname='throat.endpoints',\\n model=op.models.geometry.throat_endpoints.spherical_pores)\\npn.add_model(propname='throat.conduit_lengths',\\n model=op.models.geometry.throat_length.conduit_lengths)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create a Cloud Storage bucket\\nWhen you submit a training job using the Cloud SDK, you upload a Python package\\ncontaining your training code to a Cloud Storage bucket. AI Platform runs\\nthe code from this package. In this tutorial, AI Platform also saves the\\ntrained model that results from your job in the same bucket. You can then\\ncreate an AI Platform model version based on this output in order to serve\\nonline predictions.\\nSet the name of your Cloud Storage bucket below. It must be unique across all\\nCloud Storage buckets.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nBUCKET_NAME = \\\"[your-bucket-name]\\\"\\n\\nif BUCKET_NAME == \\\"\\\" or BUCKET_NAME is None or BUCKET_NAME == \\\"[your-bucket-name]\\\":\\n BUCKET_NAME = PROJECT_ID + \\\"_xai_flowers_\\\" + TIMESTAMP\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Conclusion\\nWe still want to figure out the answer to the original question, do we focus our efforst on mobile app or website development? Or maybe that doesn't even really matter, and Membership Time is what is really important. Let's see if we can interpret the coefficients at all to get an idea.\\n Recreate the dataframe below.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncoeffecients = pd.DataFrame(lm.coef_,X.columns)\\ncoeffecients.columns = ['Coeffecient']\\ncoeffecients\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!date > datefile.txt\\n\\n!cat datefile.txt\\n\\n!date > datefile.txt\\n\\n!cat datefile.txt\\n\\n!date >> datefile.txt\\n\\n!date >> datefile.txt\\n\\n!cat datefile.txt\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n\\\">\\\" vs \\\">>\\\"\\nBoth \\\">\\\" and \\\">>\\\" redirect output from the screen to a file. Both will create new files if none yet exists. Only \\\">\\\" will overwrite an existing file; \\\">>\\\" will append to an existing file.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"And the marginal distribution of sigma from the general.\\n\",\"targets\":\"pmf_sigma0 = general.Marginal(1)\\nthinkplot.Pdf(pmf_sigma0)\\nthinkplot.Config(xlabel='sigma', ylabel='Pmf')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Labelizer_part2.ipynb\\\".\\nThe first task is:\\nOr directly get a bigger training and testing set:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nX_train, y_train, X_test, y_test, feature_names, max_features, classes_names, vectorizer = tools.load_pickle(\\\"\\/Users\\/meat\\/Documents\\/NII\\/data\\/training_4_BacObjMetCon.pickle\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Complete the training.py DAG file\\nApache Airflow orchestrates tasks out to other services through a DAG (Directed Acyclic Graph) file which specifies what services to call, what to do, and when to run these tasks. DAG files are written in python and are loaded automatically into Airflow once present in the Airflow\\/dags\\/ folder in your Cloud Composer bucket. \\nYour task is to complete the partially written DAG file below which will enable the automatic retraining and redeployment of our WALS recommendation model. \\nComplete the #TODOs in the Airflow DAG file below and execute the code block to save the file\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%%writefile airflow\\/dags\\/training.py\\n\\n# Copyright 2018 Google Inc. All Rights Reserved.\\n#\\n# Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n# you may not use this file except in compliance with the License.\\n# You may obtain a copy of the License at\\n#\\n# http:\\/\\/www.apache.org\\/licenses\\/LICENSE-2.0\\n#\\n# Unless required by applicable law or agreed to in writing, software\\n# distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n# See the License for the specific language governing permissions and\\n# limitations under the License.\\n\\n\\\"\\\"\\\"DAG definition for recserv model training.\\\"\\\"\\\"\\n\\nimport airflow\\nfrom airflow import DAG\\n\\n# Reference for all available airflow operators: \\n# https:\\/\\/github.com\\/apache\\/incubator-airflow\\/tree\\/master\\/airflow\\/contrib\\/operators\\nfrom airflow.contrib.operators.bigquery_operator import BigQueryOperator\\nfrom airflow.contrib.operators.bigquery_to_gcs import BigQueryToCloudStorageOperator\\nfrom airflow.hooks.base_hook import BaseHook\\n# from airflow.contrib.operators.mlengine_operator import MLEngineTrainingOperator\\n# above mlengine_operator currently doesnt support custom MasterType so we import our own plugins:\\n\\n# custom plugins\\nfrom airflow.operators.app_engine_admin_plugin import AppEngineVersionOperator\\nfrom airflow.operators.ml_engine_plugin import MLEngineTrainingOperator\\n\\n\\nimport datetime\\n\\ndef _get_project_id():\\n \\\"\\\"\\\"Get project ID from default GCP connection.\\\"\\\"\\\"\\n\\n extras = BaseHook.get_connection('google_cloud_default').extra_dejson\\n key = 'extra__google_cloud_platform__project'\\n if key in extras:\\n project_id = extras[key]\\n else:\\n raise ('Must configure project_id in google_cloud_default '\\n 'connection from Airflow Console')\\n return project_id\\n\\nPROJECT_ID = _get_project_id()\\n\\n# Data set constants, used in BigQuery tasks. You can change these\\n# to conform to your data.\\n\\n# TODO: Specify your BigQuery dataset name and table name\\nDATASET = 'GA360_test'\\nTABLE_NAME =...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"05其他\\/pandas文档-zh-master\\/数据结构的内置方法.ipynb\\\".\\nThe first task is:\\n同样可以对降维后的结果再进行降维。\\nCan you write Python code for it?\\n\",\"targets\":\"\\n(df > 0).any().any()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"K Means and the UCI Wholesale Data Set.ipynb\\\".\\nThe first task is:\\nPlot K Means result with centroids.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ncentroids = sc.inverse_transform(kmeans.cluster_centers_)\\nplot_kmeans(pred, centroids, 'Frozen', 'Detergents_Paper', 3, 4, k)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Lecture_3.ipynb\\\".\\nThe first task is:\\nDictionary advanced\\nCan you write Python code for it?\\n\",\"targets\":\"\\nstudent_records = {20071213: [\\\"Alistair Darby\\\", \\\"A.C. Darby\\\"]}\\nstudent_records[20081423] = [\\\"John Smith\\\", \\\"J. L. Smith\\\"]\\nstudent_records[20096137] = [\\\"Jane Doe\\\", \\\"J. P. Doe\\\"]\\nstudent_records[20109334] = [\\\"Fred Blogs\\\",\\\"Frederick Blogs\\\",\\\"F. J. Blogs\\\"]\\n\\nprint(student_records[20109334]) # print the list for this specific key\\nfor name in student_records[20109334]: # iterate through the list and print \\n print(name, end=\\\" \\\") # each value\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Content-Based Similarities\\n| Column | Description |\\n|---|---|\\n|user_doc_ad_sim_categories, user_doc_ad_sim_topics, user_doc_ad_sim_entities | Cosine similarity between user profile and ad document profile vectors (TF-IDF).\\n|doc_event_doc_ad_sim_categories, doc_event_doc_ad_sim_topics, doc_event_doc_ad_sim_entities | Cosine similarity between event document (landing page context) and ad document profile vectors (TF-IDF).\\nPrepare training and test datasets\\n\",\"targets\":\"docs.printSchema()\\n\\ndocs_idf.drop(\\\"document_id\\\").printSchema()\\n\\nclicks = (clicks_train.withColumn(\\\"is_train\\\", F.lit(1))\\n .union(clicks_test\\n .withColumn(\\\"clicked\\\", F.lit(0))\\n .withColumn(\\\"is_train\\\", F.lit(0))))\\n\\ndf = (clicks\\n .join(events.alias(\\\"events\\\"), on = [\\\"display_id\\\"], how = \\\"left\\\")\\n .join(docs_idf.alias(\\\"docs_idf\\\"), on = [\\\"document_id\\\"], how = \\\"left\\\")\\n .join(promoted_contents.drop(\\\"document_id\\\"), on = [\\\"ad_id\\\"], how = \\\"left\\\")\\n .join(page_view_count_by_uuid, on = [\\\"uuid\\\"], how = \\\"left\\\")\\n .join(page_view_count_by_document_id, on = [\\\"document_id\\\"], how = \\\"left\\\")\\n \\n .withColumn(\\\"clicks_by_ad_id\\\", F.expr(\\\"sum(clicked) over (partition by ad_id)\\\"))\\n .withColumn(\\\"events_by_ad_id\\\", F.expr(\\\"count(*) over (partition by ad_id)\\\"))\\n .withColumn(\\\"avg_ctr_by_ad_id\\\", F.expr(\\\"clicks_by_ad_id\\/events_by_ad_id\\\"))\\n\\n .withColumn(\\\"clicks_by_campaign_id\\\", F.expr(\\\"sum(clicked) over (partition by campaign_id)\\\"))\\n .withColumn(\\\"events_by_campaign_id\\\", F.expr(\\\"count(*) over (partition by campaign_id)\\\"))\\n .withColumn(\\\"avg_ctr_by_campaign_id\\\", F.expr(\\\"clicks_by_campaign_id\\/events_by_campaign_id\\\"))\\n \\n .withColumn(\\\"clicks_by_document_id\\\", F.expr(\\\"sum(clicked) over (partition by events.document_id)\\\"))\\n .withColumn(\\\"events_by_document_id\\\", F.expr(\\\"count(*) over (partition by events.document_id)\\\"))\\n .withColumn(\\\"avg_ctr_by_document_id\\\", F.expr(\\\"clicks_by_campaign_id\\/events_by_document_id\\\"))\\n \\n .withColumn(\\\"clicks_by_advertiser_id\\\", F.expr(\\\"sum(clicked) over (partition by advertiser_id)\\\"))\\n .withColumn(\\\"events_by_advertiser_id\\\", F.expr(\\\"count(*) over (partition by advertiser_id)\\\"))\\n .withColumn(\\\"avg_ctr_by_advertiser_id\\\", F.expr(\\\"clicks_by_campaign_id\\/events_by_advertiser_id\\\"))\\n \\n .withColumn(\\\"country\\\", F.expr(\\\"split(geo_location, '>')[0]\\\"))\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Broadcasting\\nBroadcasting is a very useful feature of NumPy that will let arrays with differing shapes still be used together. In most cases, broadcasting is faster, and it is more memory efficient than the equivalent full array operation.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint(\\\"Shape of X:\\\", x.shape)\\nprint(\\\"Shape of Y:\\\", y.shape)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Comparing models\\nWe will now compare the accuracy of the sentiment_model and the simple_model using the get_classification_accuracy method you implemented above.\\nFirst, compute the classification accuracy of the sentiment_model on the train_data:\\n\",\"targets\":\"acc_sent_mod_train\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%octave\\n [b, bhead, bunits] = derivnum ('Kspa', PAR1, PAR2, PAR1TYPE, PAR2TYPE, SAL, TEMPIN, TEMPIN, PRESIN, PRESOUT,... \\n SI, PO4,...\\n pHSCALEIN, K1K2CONSTANTS, KSO4CONSTANTS);\\n# Print (nicely formatted):\\n printf(\\\"%s %s %s %s %s %s %s %s %s \\\\n\\\", bhead{10:18});\\n printf(\\\"%s %s %s %s %s %s %s %s %s \\\\n\\\", bunits{10:18});\\n printf(\\\"%f %f %f %f %f %f %f %f %f \\\\n\\\", b(10:18));\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTest to see if same results for OUT conditions when TEMPOUT = TEMPIN\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2.3. Common plots\\nExample 1: Line plot Let's create our first (line) plot:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nvals = [3,2,5,0,1]\\nplt.plot(vals)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And a few more parameters in the Params object.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nparams = Params(Rmin = 0.02 * m,\\n Rmax = 0.055 * m,\\n Mcore = 15e-3 * kg,\\n Mroll = 215e-3 * kg,\\n L = 47 * m,\\n tension = 2e-4 * N,\\n t_end = 120 * s)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"AdaBoost\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nscore(AdaBoostClassifier())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#####################################################################\\n## + 0. Read the graph\\n## Load the network routing graph first as it is the smallest. It is\\n## an undirected graph.\\nimport networkx as nx\\nG = nx.read_edgelist( \\\".\\/data\\/fb_Princeton.txt\\\", create_using = nx.DiGraph( ) );\\n\\nnode_in_degree = G.in_degree( )\\nnode_out_degree = G.out_degree( )\\n\\nin_deg = np.array( node_in_degree.values( ), dtype = np.int )\\nout_deg = np.array( node_out_degree.values( ), dtype = np.int )\\n\\n#####################################################################\\n##+ 1. Are they correspondent to power law?\\n## First let's draw the frequency plot of the node degree distribution.\\ndegree_in_freq = np.array( counts( in_deg ) )\\ndegree_out_freq = np.array( counts( out_deg ) )\\n\\nplt.title( \\\"Node degree frequency\\\" )\\nplt.xlabel( \\\"degree\\\" ) ; plt.ylabel( \\\"frequency\\\" )\\nplt.loglog( degree_out_freq[:,0], degree_out_freq[:,1], \\\"bo\\\" )\\nplt.loglog( degree_in_freq[:,0], degree_in_freq[:,1], \\\"r<\\\" )\\nplt.show( )\\n\\nplt.figure( 1, figsize = ( 10, 5 ) )\\n\\nplt.subplot(121)\\nplt.title( \\\"Degree cCDF-loglog\\\" )\\nout_cc = ccdf( out_deg, 0 )\\nplt.loglog( out_cc[:,0], out_cc[:,1], \\\"bo-\\\", linewidth = 2 )\\nin_cc = ccdf( in_deg, 0 )\\nplt.loglog( in_cc[:,0], in_cc[:,1], \\\"r<-\\\", linewidth = 2 )\\nplt.xlabel( \\\"degree\\\" ) ; plt.ylabel( \\\"probability\\\" )\\n\\nplt.subplot(122)\\n## An upward trend in plot shows heavy-tailed behaviour, but the\\n## values for high thresholds are unreliably estimated.\\nplt.title( \\\"Mean excess plot\\\" )\\nout_me = mean_excess( out_deg )\\nplt.loglog( out_me[:,0], out_me[:,1], \\\"bo-\\\", linewidth = 2 )\\nin_me = mean_excess( in_deg )\\nplt.loglog( in_me[:,0], in_me[:,1], \\\"r<-\\\", linewidth = 2 )\\nplt.ylabel( \\\"mean excess\\\" ) ; plt.xlabel( \\\"threshold\\\" )\\n\\nplt.show( )\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFacebook graph\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"All arrays has at least one dimension and a length in each dimenssion.\\n\",\"targets\":\"print(f\\\"number of dimensions={A.ndim}, shape={A.shape}\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A standard method for evaluating classification models is the confusion matrix, which summarizes both the accuracy for each individual class, as well the most-likely misclassifications for each class. [For the 2 class problem, such as ours, these quantities are essentially one and the same, but for multi-class problems this is highly helpful.] In examining the matrix, \\\"confusion\\\" for the classifier is summarized. In a confusion matrix, one axis shows the true class and the other shows the predicted class. For a perfect classifier all of the power will be along the diagonal, while confusion is represented by off-diagonal signal. \\nLike almost everything else we have encountered during this exercise, scikit-learn makes it easy to compute a confusion_matrix within the sklearn.metrics module.\\nProblem 4b Calculate (and examine) the confusion matrix for the training set from Part 1.\\n\",\"targets\":\"from sklearn.metrics import confusion_matrix\\n\\ncm = confusion_matrix(val_y, val_predsNorm)\\nprint(cm)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Collecting committees texts and analyzing it.\\nWe used a library called fataflows since it is the one used by the 'public knowledge workshop' we worked with.\\nThe data download is done in parts - each committee text is divided to parts and processed separately.\\nDownloading each knesset data and analyzing it took arround 6 hourd per knesset.\\nThis is why we kept a cache of the downloaded data and saved files of the analyzed data for each knesset.\\nConstants\\n\",\"targets\":\"# Limit processing of protocol parts for development, -1 means no limit.\\nPROCESS_PARTS_LIMIT = 1\\n\\n# Enable caching of protocol parts data (not efficient, should only be used for local development with sensible PROCESS_PARTS_LIMIT)\\nPROCESS_PARTS_CACHE = True\\n\\n# Filter the meetings to be processed, these kwargs are passed along to DataFlows filter_rows processor for meetings resource\\nMEETINGS_FILTER_ROWS_KWARGS = {'equals': [{'KnessetNum': 20}]}\\n\\n# Don'e use local data - loads everything from knesset data remote storage\\n# When set to False - also enables caching, so you won't download from remote storage on 2nd run.\\nUSE_DATA = False\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Basic matrix multiplication\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nA = Matrix([[a11, a12, a13], [a21, a22, a23]])\\nB = Matrix([[b11, b12], [b21, b22], [b31, b32]])\\nA, B\\n\\nC = A * B\\nC\\n\\nA = Matrix([[3, 1], [1, 3]])\\nB = Matrix ([[1, 2], [1,4]])\\nC1 = A * B\\nC2 = B * A\\nC1, C2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapter 5 - Functions and Files.ipynb\\\".\\nThe first task is:\\nYou need to write:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nf = open('data\\/testoutput.txt','wt', encoding='utf-8')\\nf.write(\\\"Hello world on the first line!\\\\n\\\")\\nf.write(\\\"Hello world on the second line!\\\")\\nf.close()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# compile the new model\\nopt = RMSprop(lr=0.1)\\nmodel.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])\\n\\n# then fit it\\nfit_model(model, batches, val_batches, nb_epoch=2)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIt'll run a bit slowly since it has to calculate all previous layers in order to know what input to pass to the new final layer. We can save time by precalculating the output of the penultimate layer, like we did for the final layer earlier. Note for later work.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Chromae also carry all the logic needed for musical manipulation and mathematical representation.\\n\",\"targets\":\"int(ophis.FSHARP) \\n\\nophis.FSHARP.augment()\\n\\nophis.FSHARP.diminish()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A noter que si vous voyez apparaître vos résultats sous la forme (79145543,), c'est normal, le curseur sqlite renvoit toujours ces résultats sous forme de tuple : (colonne1, colonne2, colonne3, ...) et ce même si il n'y a qu'une seule colonne dans la requête. Nous utiliserons pluck pour extraire le premier élément du tuple.\\nQuestion 2 - nombre d'élements unique d'une table\\nTrouvez le nombre de user_id différents dans la table tw_followers_id, en utilisant les fonctions cytoolz.\\nLes fonctions qui pourront vous êtres utiles ici : \\n\\nct.count(seq) => compte le nombre d'éléments d'une séquence\\nct.unique(seq) => à partir d'une séquence, renvoit une séquence où tous les doublons ont été supprimés\\n\\nVous vous rappelez sans doute que nous utilisions systématiquement pluck et map pour les exemples du cours, ceux-ci ne sont pas nécessaires, ici.\\n\",\"targets\":\"import cytoolz as ct \\nimport cytoolz.curried as ctc\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Conclusion: Colors are slightly affected by changing the continum model.\\nTo Finalize the LYA section, lets generate another set of spectra now including DLAs, metals, LYB, etc.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndel sys.modules['desitarget.mock.mockmaker']\\nfrom desitarget.mock.mockmaker import LYAMaker ##Done in order to reload the desitarget, it doesn't seem to be enough with initiating a diferent variable for the LYAMaker class. \\n\\nLYA = LYAMaker(seed=seed,sqmodel='lya_simqso_model',balprob=0.25,add_dla=True,add_metals=\\\"all\\\",add_lyb=True)\\nlyadata_all= LYA.read(mockfile=mockfile,healpixels=healpixel, nside=nside)\\n%time lyaflux_all, lyawave_all, lyatargets_all, lyatruth_all, lyaobjtruth_all = LYA.make_spectra(lyadata_all)\\n\\nplot_subset(lyawave_all, lyaflux_all, lyatruth_all, lyaobjtruth_all, xlim=(3500, 5500), targname='LYA')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Linear_Regression_Overfitting_Demo_Ridge_Lasso.ipynb\\\".\\nThe first task is:\\nPlot results of estimating LOO for each value of lambda\\nCan you write Python code for it?\\n\",\"targets\":\"\\nplt.plot(l2_penalty_values,l2_penalty_mse,'k-')\\nplt.xlabel('$\\\\ell_2$ penalty')\\nplt.ylabel('LOO cross validation error')\\nplt.xscale('log')\\nplt.yscale('log')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Notebooks\\/Make_Hazard_Curves_interactive.ipynb\\\".\\nThe first task is:\\nSet the exceedance values\\nThis should be a list or array of values $\\\\zeta$ (zeta) representing depth of flooding on shore, or elevation above sea level offshore (in meters). The hazard curves will be computed by determining the annual probability that the maximum $\\\\zeta$ observed at each spatial point is above $\\\\zeta_k$, for each value $\\\\zeta_k$ in this list.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# these levels were used in original study:\\n#zeta = hstack((arange(0,2.,.1), arange(2.0,12.5,.5))) \\n\\n# you get nicer looking curves by using a denser set of exceedance values:\\nzeta = linspace(0,12,121)\\nnzeta = len(zeta)\\nprint('%i exceedance values, \\\\nzeta = %s' % (nzeta,zeta))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Beispiel:\\nWir haben von jedem Block drei Bilder:\\n- kein Smoothing (s000)\\n- 8mm Smoothing (s008)\\n- 16mm Smoothing (s016)\\n\",\"targets\":\"from nilearn import plotting\\nimport matplotlib.pylab as plt\\n%matplotlib inline\\n\\nfor img in imgList[:3]:\\n plotting.plot_stat_map(img,title=img)\\n plt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"03-Project-McNulty\\/Random_Forest_Parameter_Tuning.ipynb\\\".\\nThe first task is:\\nLet's contast our best model so far with no class weights.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmodel2 = RandomForestClassifier(n_estimators=23, n_jobs=-1, criterion='gini', min_samples_split=10, class_weight=None, random_state=222)\\n\\ny_pred = cross_val_predict(model2, X, y, cv=cv2, n_jobs=-1)\\n\\nprint(classification_report(y, y_pred,target_names=target_names))\\n\\nprint()\\n\\ncnf_matrix = confusion_matrix(y, y_pred)\\n\\nprint(\\\"Accuracy Score: \\\", np.median(accuracy_score(y, y_pred)))\\n\\nprint()\\n\\nprint(\\\"F1 score - Binary: \\\", np.median(f1_score(y, y_pred, average='binary')))\\nprint()\\nprint(\\\"F1 score - Micro: \\\", np.median(f1_score(y, y_pred, average='micro')))\\nprint()\\nprint(\\\"F1 score - Weighted: \\\", np.median(f1_score(y, y_pred, average='weighted')))\\nprint()\\nshow_confusion_matrix(cnf_matrix, class_labels=target_names)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Lab04\\/ML_lab4_ctr_student.ipynb\\\".\\nThe first task is:\\nPart 4: CTR prediction and logloss evaluation \\n (4a) Logistic regression \\nWe are now ready to train our first CTR classifier. A natural classifier to use in this setting is logistic regression, since it models the probability of a click-through event rather than returning a binary response, and when working with rare events, probabilistic predictions are useful. First use LogisticRegressionWithSGD to train a model using OHETrainData with the given hyperparameter configuration. LogisticRegressionWithSGD returns a LogisticRegressionModel. Next, use the LogisticRegressionModel.weights and LogisticRegressionModel.intercept attributes to print out the model's parameters. Note that these are the names of the object's attributes and should be called using a syntax like model.weights for a given model.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom pyspark.mllib.classification import LogisticRegressionWithSGD\\n\\n# fixed hyperparameters\\nnumIters = 50\\nstepSize = 10.\\nregParam = 1e-6\\nregType = 'l2'\\nincludeIntercept = True\\n\\n# TODO: Replace with appropriate code\\nmodel0 = LogisticRegressionWithSGD.train(OHETrainData, numIters, stepSize, regParam=regParam, regType=regType, intercept=includeIntercept)\\nsortedWeights = sorted(model0.weights)\\nprint sortedWeights[:5], model0.intercept\\n\\n# TEST Logistic regression (4a)\\nTest.assertTrue(np.allclose(model0.intercept, 0.56455084025), 'incorrect value for model0.intercept')\\nTest.assertTrue(np.allclose(sortedWeights[0:5],\\n [-0.45899236853575609, -0.37973707648623956, -0.36996558266753304,\\n -0.36934962879928263, -0.32697945415010637]), 'incorrect value for model0.weights')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# This requires that we import a few new libraries\\nfrom assaytools import platereader\\nimport string\\n\\n\\nPtot = 0.5e-6 * np.ones([24],np.float64) # protein concentration, M\\nLtot = np.array([20.0e-6,14.0e-6,9.82e-6,6.88e-6,4.82e-6,3.38e-6,2.37e-6,1.66e-6,1.16e-6,0.815e-6,0.571e-6,0.4e-6,0.28e-6,0.196e-6,0.138e-6,0.0964e-6,0.0676e-6,0.0474e-6,0.0320e-6,0.0240e-6,0.0160e-6,0.0120e-6,0.008e-6,0.00001e-6], np.float64) # ligand concentration, M\\n\\nsinglet_file = '.\\/data\\/p38_singlet1_20160420_153238.xml'\\n\\ndata = platereader.read_icontrol_xml(singlet_file)\\n\\n#I want the Bosutinib-p38 data from rows I (protein) and J (buffer).\\ndata_protein = platereader.select_data(data, '280_480_TOP_120', 'I')\\ndata_buffer = platereader.select_data(data, '280_480_TOP_120', 'J')\\n\\ndata_protein\\n\\n#Sadly we also need to reorder our data and put it into an array to make the analysis easier\\n#This whole thing should be moved to assaytools.platereader hopefully before too many other people see this.\\n\\nwell = dict()\\nfor j in string.ascii_uppercase:\\n for i in range(1,25):\\n well['%s' %j + '%s' %i] = i\\n\\ndef reorder2list(data,well):\\n \\n sorted_keys = sorted(well.keys(), key=lambda k:well[k])\\n \\n reorder_data = []\\n \\n for key in sorted_keys:\\n try:\\n reorder_data.append(data[key])\\n except:\\n pass\\n\\n reorder_data = [r.replace('OVER','70000') for r in reorder_data]\\n \\n reorder_data = np.asarray(reorder_data,np.float64)\\n \\n return reorder_data\\n\\nreorder_protein = reorder2list(data_protein,well)\\nreorder_buffer = reorder2list(data_buffer,well)\\n\\nreorder_protein\\n\\nplt.semilogx(Ltot,reorder_protein, 'ro', label='PL')\\nplt.semilogx(Ltot,reorder_buffer, 'ko', label='L')\\nplt.xlabel('$[L]_{tot}$ \\/ M')\\nplt.ylabel('fluorescence')\\nplt.xlim(5e-9,1.3e-4)\\nplt.legend(loc=2);\\n\\n# for this to work we need to provide some initial values\\n# some of these we already have\\nF_i = reorder_protein\\n\\n#And makeup an F_L\\nF_L = 0.3\\n\\n# initial guess for [F_background, F_PL, Kd]\\ninitial_guess = [0,400\\/1e-9,2e-9]\\n\\nF_i\\n\\nfit =...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPart II\\nNow we will see how well this does for real data.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"<\\/a>\\nEager execution\\nEager execution is an imperative programming\\nenvironment that evaluates operations immediately. This is not required for\\nKeras, but is supported by tf.keras and useful for inspecting your program and\\ndebugging.\\nAll of the tf.keras model-building APIs are compatible with eager execution.\\nAnd while the Sequential and functional APIs can be used, eager execution\\nespecially benefits model subclassing and building custom layers—the APIs\\nthat require you to write the forward pass as code (instead of the APIs that\\ncreate models by assembling existing layers).\\nSee the eager execution guide for\\nexamples of using Keras models with custom training loops and tf.GradientTape.\\nDistribution\\nEstimators\\nThe Estimators API is used for training models\\nfor distributed environments. This targets industry use cases such as\\ndistributed training on large datasets that can export a model for production.\\nA tf.keras.Model can be trained with the tf.estimator API by converting the\\nmodel to an tf.estimator.Estimator object with\\ntf.keras.estimator.model_to_estimator. See\\nCreating Estimators from Keras models.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmodel = tf.keras.Sequential([layers.Dense(64, activation='relu', input_shape=(32,)),\\n layers.Dense(10,activation='softmax')])\\n\\nmodel.compile(optimizer=tf.train.RMSPropOptimizer(0.001),\\n loss='categorical_crossentropy',\\n metrics=['accuracy'])\\n\\nestimator = tf.keras.estimator.model_to_estimator(model)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Lab4\\/lab4.ipynb\\\".\\nThe first task is:\\nCheck\\nFollowing numbers should be almost equal to zero (almost because of machine)\\nCan you write Python code for it?\\n\",\"targets\":\"\\nresults = ((- b + lambdas[1]) * (a + lambdas[1]) + a*b,\\n (- b + lambdas[0]) * (a + lambdas[0]) + a*b)\\nassert np.allclose(results, (0., 0.))\\nresults\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Connect to the CAS server\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nconn = swat.CAS('sasserver.demo.sas.com',8777,'sasdemo','Orion123')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# plot the histogram\\nax = smps.plots.histplot(s.dndlogdp, s.bins, plot_kws={'linewidth': 0, 'alpha': .6, 'edgecolor': None},\\n fig_kws={'figsize': (12, 6)})\\n\\n# Plot the fit values\\nax.plot(X, results.fittedvalues, lw=6, label=\\\"Fit Data\\\")\\n\\nax.set_ylabel(\\\"$dN\\/dlogD_p \\\\; [cm^{-3}]$\\\")\\nax.set_title(\\\"Wintertime in Cambridge, MA with Fit Data\\\")\\n\\n# remove the spines of the plot\\nsns.despine()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAbove, we see the results for the three fit parameters: Number of particles per cubic centimeter, the geometric mean diameter, and the geometric standard deviation. All three have error estimates (standard deviation) as shown in parentheses next to each value.\\nNow that we successfully fit our data, let's go ahead and plot it over the histogram:\\nPlot Histogram with Fit Data\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Analyze the model\\nThe R^2 error for both model are pretty similar. The SVR model yield a better result because of lower R^2 rate. To show the difference between these two model compare with true label, we use matplotlib to plot the result of our predictions.\\n\",\"targets\":\"\\nplt.plot(y_pre_svr, label=\\\"Prediction for SVR\\\")\\nplt.plot(y_te.values, label=\\\"Heating Load\\\")\\nplt.plot(y_lin_svr, label=\\\"Prediction for linear\\\")\\nplt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\\n ncol=2, mode=\\\"expand\\\", borderaxespad=0.)\\nplt.show()\\n\\ntrain, test = train_test_split(df, test_size = 0.3)\\nX_tr = train.drop(['Y1','Y2'], axis=1)\\ny_tr = train['Y2']\\ntest = test.sort_values('Y2')\\nX_te = test.drop(['Y1','Y2'], axis=1)\\ny_te = test['Y2']\\n\\nreg_svr = svm.SVR()\\nreg_svr.fit(X_tr, y_tr)\\n\\nreg_lin = linear_model.LinearRegression()\\nreg_lin.fit(X_tr, y_tr)\\n\\ny_pre_svr = reg_svr.predict(X_te)\\ny_lin_svr = reg_lin.predict(X_te)\\nprint (\\\"Coefficient R^2 of the SVR prediction: \\\" + str(reg_svr.score(X_tr, y_tr)))\\nprint (\\\"Coefficient R^2 of the Linear Regression prediction: \\\" + str(reg_lin.score(X_tr, y_tr)))\\n\\nplt.plot(y_pre_svr, label=\\\"Prediction for SVR\\\")\\nplt.plot(y_te.values, label=\\\"Cooling Load\\\")\\nplt.plot(y_lin_svr, label=\\\"Prediction for linear\\\")\\nplt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\\n ncol=2, mode=\\\"expand\\\", borderaxespad=0.)\\nplt.show()\\n\\n# coefficients of linear model\\nprint (reg_lin.coef_)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"01_parsing.ipynb\\\".\\nThe first task is:\\nTesting your functions is key\\nA couple of quick tests should suffice...though these barely make the cut...\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(len(df) == nframe * nat) # Make sure that we have the correct number of rows\\nprint(df.dtypes) # Make sure that each column's type is correct\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Type the above command here and run it\\n\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWhat type of object is each variable above? Try:\\ntype(my_file_name)\\ntype(my_file_handle)\\ntype(my_file_contents)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"## kwargs common for x and y data\\nkwargs = {\\n #'roi_wavenumber' : slice(2200, 2800),\\n}\\n\\n## select some y data\\nydata = d0.select(\\n 'track', \\n roi_wavenumber=slice(2200, 2800),\\n roi_spectra=slice(0, 2),\\n **kwargs,\\n)\\n\\nfig, ax = subplots()\\nsfg2d.plot.track(None, ydata)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTrack\\nA track plots the pixel wise sum of a spectrum vs the time of a spectraum. By Looking a the track, you can see if your measurment was stable or, or if the internsity changed during time.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Q. Create an initializer with a normal distribution of mean equals 0 and standard deviation equals 2.\\ninit = ...\\n\\ntf.reset_default_graph()\\nx = tf.get_variable('x', shape=[10, 1000], initializer=init)\\n\\nwith tf.Session():\\n x.initializer.run()\\n _x = x.eval()\\n print(\\\"Make sure the mean\\\", np.mean(_x), \\\"is close to 0\\\" )\\n print(\\\"Make sure the standard deviation\\\", np.std(_x), \\\"is close to 2\\\" )\\n \\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nQ19. Complete this code.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"7). I'd like to see all of the 311 complaints called in on April 1st.\\n\\nSurprise! We couldn't do this in class, but it was just a limitation of our data set\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nApril = df['2015-04']\\nApril.sort('created_datetime').head()\\n\\nApril[:\\\"20150401\\\"]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Cleaning our Analysis DataFrame\\nTo simplify our analysis, any row without a corresponding country population or a corresponding article quality will be removed from the data set. We perform some additional cleaning by ordering our rows, renaming our columns and representing population as an integer before writing it out to the clean_data directory.\\nOur DataFrame will look like the following:\\n| Column | Value |\\n|-----------------------|\\n| country | Name of the Country the article belongs to |\\n| article_name | Name of the Wikipedia article |\\n| revision_id | Integer ID that maps to the given Wikipedia page's last edit |\\n| article_quality | Quality of the Article as determined by ORES |\\n| population | Number of people living in the country in mid-2015 |\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Filter out any countries without a population or without an article quality\\ndf = politician_df[(pd.notnull(politician_df.population)) & (pd.notnull(politician_df.article_quality))]\\n\\nprint(\\\"{} rows were removed\\\".format(politician_df.shape[0] - df.shape[0]))\\n\\n# Reorder columns\\ndf = df[[\\\"country\\\", \\\"page\\\", \\\"rev_id\\\", \\\"article_quality\\\", \\\"population\\\"]]\\n\\n# Rename columns to match assignment definition\\ndf.columns = [\\\"country\\\", \\\"article_name\\\", \\\"revision_id\\\", \\\"article_quality\\\", \\\"population\\\"]\\n\\n# Change population column to integer\\ndf.loc[:, \\\"population\\\"] = df[\\\"population\\\"].astype(int)\\n\\n# Write analysis data set out to file\\ncleaned_data_file_path = \\\".\\/clean_data\\/en-wikipedia_politician_article_quality.csv\\\"\\ndf.to_csv(cleaned_data_file_path, index=False)\\n\\n# Print example of analysis DataFrame\\ndf.head(4)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Data Visualization\\/Lab 8\\/w08_lab_Vipul_Munot.ipynb\\\".\\nThe first task is:\\nOr using seaborn:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nsns.distplot(movie_df['Rating'], bins=10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Solution\\n\\ndie = Pmf(dict(red=2, blue=4))\\ndie.Normalize()\\ndie.Print()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExerise: Create a Pmf that represents a six-sided die that is red on two sides and blue on the other four.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"But this gets tedious very quickly. Instead, we can calculate a statisical summary over a particular axis of the array: along its rows or along its columns.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nbarrow.mean()\\n\\nbarrow.mean(axis = 1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"<\\/a>\\nInference: Priming\\nLet's now work on \\\"priming\\\" the model with some text, and see what kind of state it is in and leave it to synthesize from there. We'll do more or less what we did before, but feed in our own text instead of the last letter of the synthesis from the model.\\n\",\"targets\":\"prime = \\\"obama\\\"\\ntemperature = 1.0\\ncurr_states = None\\nn_iterations = 500\\ng = tf.Graph()\\nwith tf.Session(graph=g) as sess:\\n model = charrnn.build_model(txt=txt,\\n batch_size=1,\\n sequence_length=1,\\n n_layers=n_layers,\\n n_cells=n_cells,\\n gradient_clip=10.0)\\n saver = tf.train.Saver()\\n if os.path.exists(ckpt_name):\\n saver.restore(sess, ckpt_name)\\n print(\\\"Model restored.\\\")\\n \\n # Get every tf.Tensor for the initial state\\n init_states = []\\n for s_i in model['initial_state']:\\n init_states.append(s_i.c)\\n init_states.append(s_i.h)\\n \\n # Similarly, for every state after inference\\n final_states = []\\n for s_i in model['final_state']:\\n final_states.append(s_i.c)\\n final_states.append(s_i.h)\\n\\n # Now we'll keep track of the state as we feed it one\\n # letter at a time.\\n curr_states = None\\n for ch in prime:\\n feed_dict = {model['X']: [[model['encoder'][ch]]],\\n model['keep_prob']: 1.0}\\n if curr_states:\\n feed_dict.update(\\n {init_state_i: curr_state_i\\n for (init_state_i, curr_state_i) in\\n zip(init_states, curr_states)})\\n \\n # Now we can infer and see what letter we get\\n p = sess.run(model['probs'], feed_dict=feed_dict)[0]\\n p = p.astype(np.float64)\\n p = np.log(p) \\/ temperature\\n p = np.exp(p) \\/ np.sum(np.exp(p))\\n p = np.random.multinomial(1, p.ravel() \\/ p.sum())\\n p = np.argmax(p)\\n \\n # And make sure we also keep track of the new state\\n curr_states = sess.run(final_states, feed_dict=feed_dict)\\n \\n # Now we're ready to do what we were doing before but with the\\n # last predicted output stored in `p`, and the current state of\\n # the model.\\n synth = [[p]]\\n print(prime + model['decoder'][p], end='')\\n for i...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Cortar\\nPara extraer secciones especificas de lineas de los archivos usamos la instrucción cut.\\n\",\"targets\":\"%%bash\\nls -oh\\nls -oh | grep -Ev '[[:alpha:]]+ [[:alnum:]]+\\\\.ipynb|total' | grep -Ev '[a-z]{3} ' > cortar\\necho \\\":: archivo cortar seleccionando lineas ::\\\"\\ncat cortar\\necho \\\":: Horas enteras de los archivos ::\\\"\\ncut -d \\\" \\\" -f 7 cortar | cut -c 1-2 > horas\\ncut -d \\\" \\\" -f 7 cortar | cut -c 4-5 > minutos\\necho \\\":: Horas ::\\\"\\ncat horas\\necho \\\":: Minutos ::\\\"\\ncat minutos\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%sql\\nWITH SSNS(SSN) AS (\\n VALUES \\n '123-34-1322',\\n 'ABC-34-9999',\\n 'X123-44-0001',\\n '123X-Y44-Z0001',\\n '111-222-111'\\n )\\nSELECT SSN,\\n CASE \\n WHEN REGEXP_LIKE(SSN,'^[0-9]{3}-[0-9]{2}-[0-9]{4}$') THEN 'Valid'\\n ELSE 'Invalid'\\n END\\nFROM SSNS\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIf you check closely, one of the strings was marked as\\nvalid, although it is not correct (X123-44-0001). The reason\\nthis occurred is that the pattern was found after the \\\"X\\\"\\nand it was correct. To prevent this from happening, we need\\nto anchor the pattern at the beginning to avoid this\\nsituation. A better pattern would be to anchor both ends of\\nthe pattern so there is no possibility of other characters\\nbeing at the beginning or end of the pattern.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!gmsh -2 .\\/_workdir\\/mesh.geo -algo 'delquad' \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nMesh creation\\nGMSH can be run directly as a shell command.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Pandas\\/Pandas plotting.ipynb\\\".\\nThe first task is:\\nThis didn't work in this case, because the boxplot function works by drawing a single box for each column specified in the dataframe. In order to create the expected plot, we therefore have to use the pivoted table we created at the beginning:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf_pivot.head()\\n\\ndf_pivot.plot(kind='box')\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"As for the title, this is pretty clean and useful.\\nRicher Fields\\nThe description, exact time, the website or a direct subscription_link are not required for what we want. Our goal is not to speed up the process of our users subscribing to a specific event but to have them realize that there are many of them and that they should dig a bit more this way of enlarging their network or improving their job search.\\nHowever it would be useful to get all those details from a secondary page if they wanted to. From the WorkUp website, there are pages with full details that are accessible with a URL like this one: https:\\/\\/www.workuper.com\\/events\\/salon-des-10-000-emplois-marseille. The good thing is that the dataset contains the last part of the URL in the slug field. So we will keep this field to rebuild the full page URLs.\\nOthers\\nLet's check the price field: we could decide to hide events that are not free, or at least warn our users early.\\n\",\"targets\":\"events[['title', 'price']]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"##new normalized Planck function definition\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n\\n#### Exercise 3d\\nWrite a paragraph describing the differences between the areas under these three curves and what that means about their total energy output. Be as quantitative as possible by estimating the area underneath them. \\n\\n***Insert your description here***\\n\\n\\n#### Exercise 3e\\n\\nwrite a new function, planck_norm, that does the same thing as the Planck function, but ***normalizes*** the function by the peak value. To do this, divide the flux array by its maximum value. This serves to make all of the curves peak at 1 so that you can easily compare where they peak.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"19. What percentage of Households don't fit in any of the other categories?\\n\",\"targets\":\"f=slums['percentageoftenure_other'].mean()\\n\\nplt.style.use('ggplot')\\nseries=pd.Series([a,b,c,d,e,f], index=['Pattas', 'PC', 'Private Land','Public Land','Renters','Others'], name='Tenuree Type')\\nseries.plot.pie(figsize=(6, 6))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapter4_TheGreatestTheoremNeverTold\\/Ch4_LawOfLargeNumbers_PyMC3.ipynb\\\".\\nThe first task is:\\nWhat do we observe? Without accounting for population sizes we run the risk of making an enormous inference error: if we ignored population size, we would say that the county with the shortest and tallest individuals have been correctly circled. But this inference is wrong for the following reason. These two counties do not necessarily have the most extreme heights. The error results from the calculated average of smaller populations not being a good reflection of the true expected value of the population (which in truth should be $\\\\mu =150$). The sample size\\/population size\\/$N$, whatever you wish to call it, is simply too small to invoke the Law of Large Numbers effectively. \\nWe provide more damning evidence against this inference. Recall the population numbers were uniformly distributed over 100 to 1500. Our intuition should tell us that the counties with the most extreme population heights should also be uniformly spread over 100 to 1500, and certainly independent of the county's population. Not so. Below are the population sizes of the counties with the most extreme heights.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(\\\"Population sizes of 10 'shortest' counties: \\\")\\nprint(population[ np.argsort( average_across_county )[:10] ], '\\\\n')\\nprint(\\\"Population sizes of 10 'tallest' counties: \\\")\\nprint(population[ np.argsort( -average_across_county )[:10] ])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2020\\/05-geographic-information-system\\/Notebook_Geometric_Objects.ipynb\\\".\\nThe first task is:\\nVamos chamar a função interna Convex Hull\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Convex Hull of our MultiPoint --> https:\\/\\/en.wikipedia.org\\/wiki\\/Convex_hull\\nconvex = multi_point.convex_hull\\n\\nprint(\\\"Convex hull of the points: \\\", convex)\\nconvex\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"An Image object uses the NumPy buffer interface. This means that you can use an Image object everywhere where you can use a NumPy array, and you can use a NumPy array anywhere where you would use an Image object.\\nHere we create a NumPy array and display it like it were an Image (remember that NumPy uses height as the first dimension and width as the second one, this is reverse from how PyDIP does it):\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport numpy as np\\n\\nb = np.random.rand(a.Size(1), a.Size(0))\\ndip.Show(b)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2)Who are the top 10 richest billionaires?\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nrecent.sort_values(by='rank').head(10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Configuring the outputs and observations\\nPEST needs to know what its calibrating to. In our case, that means a time series of observed data, and a corresponding modelled time series. We also need the objective function and the time period for the calibration.\\nPEST has a tool for processing time series data (TSPROC) but we don't use it here. Rather, we compute the objective values in Python and just pass single numbers back to PEST.\\nWe'll start by loading the observed flow time series data into this notebook and exploring the data a bit...\\nNote: Loading the data at this point serves two purposes:\\n1. We become more familiar with the data and can identify things like the time period we want to calibrate over, and\\n2. We work out the exact pandas command needed to load the data. We need to give this command to PEST later on to call as part of the simulations...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport pandas as pd\\nflows = pd.read_csv('SyntheticObservedFlow.csv',parse_dates=True,dayfirst=True,index_col=0)\\nflows[0::50] # Show every fifty days\\n\\nflows.plot()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# 3. Jumping rabit\\nmem = {}\\ndef jump_rabit(m: int):\\n \\\"\\\"\\\"\\\"\\\"\\\"\\n\\n if m <= 3:\\n return m-1\\n\\n if m in mem.keys():\\n return mem[m]\\n else:\\n mem[m] = jump_rabit(m-1) + jump_rabit(m-2)\\n\\n return mem[m]\\n\\n# test\\nm = 3\\nprint(jump_rabit(m))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n3. Jumping rabit!\\nProblems: \\nTHe road map for the rabit is a list with length of $m$, the rabit can either jump 1 step or 2 steps per jump. How many jumping methods are there for the rabit reach the end (never jump back).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Aggregation\\nThe LArray library includes many aggregations methods: sum, mean, min, max, std, var, ...\\nFor example, assuming we still have an array in the population variable:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npopulation\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\n\\nSources\\nBack to TOC\\n\\nSee Textbook: Numerical Analysis, Timothy Sauer, 2nd Edition, page 305.\\nhttps:\\/\\/en.wikipedia.org\\/wiki\\/Pendulum_(mathematics)\\nhttps:\\/\\/en.wikipedia.org\\/wiki\\/Double_pendulum\\nhttps:\\/\\/scienceworld.wolfram.com\\/physics\\/DoublePendulum.html\\nhttps:\\/\\/demonstrations.wolfram.com\\/DoublePendulum\\/\\nWorld Pendulum Alliance: http:\\/\\/wpa.tecnico.ulisboa.pt\\/~wpa.daemon\\/\\nWorld Pendulum Alliance at USM: http:\\/\\/wpa.tecnico.ulisboa.pt\\/~wpa.daemon\\/hei-partners\\/p10-universidad-tecnica-federico-santa-maria-utfsm\\/\\n\\n\\n\\nThe Pendulum\\nBack to TOC\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nplt.figure(figsize=(8,8))\\nax=plt.gca()\\ntheta0=np.pi\\/4\\nx=np.sin(theta0)\\ny=-np.cos(theta0)\\nplt.plot([0, x],[0, y],'-k')\\nplt.scatter(x, y, s=200, marker='o', c='b')\\nplt.scatter(0, 0, s=200, marker='o', c='k')\\nplt.xlim([-1.5,1.5])\\nplt.ylim([-1.5,0.5])\\nplt.grid(True)\\npatches=[]\\nwedge = mpatches.Wedge((0, 0), 0.7, 270, 270+45, ec=\\\"none\\\")\\npatches.append(wedge)\\ncollection = PatchCollection(patches, cmap=plt.cm.hsv, alpha=0.3)\\nax.add_collection(collection)\\nplt.text(0.1, -0.4, r'$\\\\theta$', fontsize=20)\\nplt.text(0.8, -0.7, r'$m$', fontsize=20)\\nplt.text(0.35, -0.25, r'$l$', fontsize=20)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# TODO: Compile and train the model here.\\nmodel.compile('adam', 'categorical_crossentropy', ['accuracy'])\\nhistory = model.fit(X_normalized, y_one_hot, nb_epoch=10, validation_split=0.2)\\n\\n# STOP: Do not change the tests below. Your implementation should pass these tests.\\nfrom keras.optimizers import Adam\\n\\nassert model.loss == 'categorical_crossentropy', 'Not using categorical_crossentropy loss function'\\nassert isinstance(model.optimizer, Adam), 'Not using adam optimizer'\\nassert len(history.history['acc']) == 10, 'You\\\\'re using {} epochs when you need to use 10 epochs.'.format(len(history.history['acc']))\\n\\nassert history.history['acc'][-1] > 0.92, 'The training accuracy was: %.3f. It shoud be greater than 0.92' % history.history['acc'][-1]\\nassert history.history['val_acc'][-1] > 0.85, 'The validation accuracy is: %.3f. It shoud be greater than 0.85' % history.history['val_acc'][-1]\\nprint('Tests passed.')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTraining a Sequential Model\\nYou built a multi-layer neural network in Keras, now let's look at training a neural network.\\n```python\\nfrom keras.models import Sequential\\nfrom keras.layers.core import Dense, Activation\\nmodel = Sequential()\\n...\\nConfigures the learning process and metrics\\nmodel.compile('sgd', 'mean_squared_error', ['accuracy'])\\nTrain the model\\nHistory is a record of training loss and metrics\\nhistory = model.fit(x_train_data, Y_train_data, batch_size=128, nb_epoch=2, validation_split=0.2)\\nCalculate test score\\ntest_score = model.evaluate(x_test_data, Y_test_data)\\n``\\nThe code above configures, trains, and tests the model. The linemodel.compile('sgd', 'mean_squared_error', ['accuracy'])configures the model's optimizer to'sgd'(stochastic gradient descent), the loss to'mean_squared_error', and the metric to'accuracy'`. \\nYou can find more optimizers here, loss functions here, and more metrics here.\\nTo train the model, use the fit() function as shown in model.fit(x_train_data, Y_train_data, batch_size=128, nb_epoch=2, validation_split=0.2). The validation_split parameter will split a percentage of the training dataset to be used to validate the model. The model can be further tested with the test dataset using the evaluation() function as shown in the last line.\\nTrain the Network\\n\\nCompile the network using adam optimizer and categorical_crossentropy loss function.\\nTrain the network for ten epochs and validate with 20% of the training data.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# PROPERTY ID - DO NOT EDIT ! \\nDOC.set_id('cmip6.ocnbgchem.tracers.nutrients_present') \\n\\n# PROPERTY VALUE(S): \\n# Set as follows: DOC.set_value(\\\"value\\\") \\n# Valid Choices: \\n# \\\"Nitrogen (N)\\\" \\n# \\\"Phosphorous (P)\\\" \\n# \\\"Silicium (S)\\\" \\n# \\\"Iron (Fe)\\\" \\n# \\\"Other: [Please specify]\\\" \\n# TODO - please enter value(s)\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n8.3. Nutrients Present\\nIs Required: TRUE Type: ENUM Cardinality: 1.N\\nList nutrient species present in ocean biogeochemistry model\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Answer these 3 questions without typing code. Then type code to check your answer.\\nWhat is the value of the expression 4 * (6 + 5)\\n\\nWhat is the value of the expression 4 * 6 + 5\\n\\nWhat is the value of the expression 4 + 6 * 5\\n\",\"targets\":\"print 4*(6+5)\\nprint 4*6+5\\nprint 4+6*5\\nprint 3+1.5+4\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"05_resilience\\/continuous_eval.ipynb\\\".\\nThe first task is:\\nNow, every time this model version receives an online prediction request, this information will be captured and stored in the BQ table. Note, this happens everytime because we set the sampling proportion to 100%. \\nSend prediction requests to your model\\nHere are some article titles and their groundtruth sources that we can test with prediciton.\\n| title | groundtruth |\\n|---|---|\\n| YouTube introduces Video Chapters to make it easier to navigate longer videos | techcrunch |\\n| A Filmmaker Put Away for Tax Fraud Takes Us Inside a British Prison | nytimes |\\n| A native Mac app wrapper for WhatsApp Web | github |\\n| Astronauts Dock With Space Station After Historic SpaceX Launch | nytimes |\\n| House Passes Sweeping Policing Bill Targeting Racial Bias and Use of Force | nytimes |\\n| Scrollability | github |\\n| iOS 14 lets deaf users set alerts for important sounds, among other clever accessibility perks | techcrunch |\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%%writefile input.json\\n{\\\"text\\\": \\\"YouTube introduces Video Chapters to make it easier to navigate longer videos\\\"}\\n\\n!gcloud ai-platform predict \\\\\\n --model txtcls \\\\\\n --json-instances input.json \\\\\\n --version swivel\\n\\n%%writefile input.json\\n{\\\"text\\\": \\\"A Filmmaker Put Away for Tax Fraud Takes Us Inside a British Prison\\\"}\\n\\n!gcloud ai-platform predict \\\\\\n --model txtcls \\\\\\n --json-instances input.json \\\\\\n --version swivel\\n\\n%%writefile input.json\\n{\\\"text\\\": \\\"A native Mac app wrapper for WhatsApp Web\\\"}\\n\\n!gcloud ai-platform predict \\\\\\n --model txtcls \\\\\\n --json-instances input.json \\\\\\n --version swivel\\n\\n%%writefile input.json\\n{\\\"text\\\": \\\"Astronauts Dock With Space Station After Historic SpaceX Launch\\\"}\\n\\n!gcloud ai-platform predict \\\\\\n --model txtcls \\\\\\n --json-instances input.json \\\\\\n --version swivel\\n\\n%%writefile input.json\\n{\\\"text\\\": \\\"House Passes Sweeping Policing Bill Targeting Racial Bias and Use of Force\\\"}\\n\\n!gcloud ai-platform predict \\\\\\n --model txtcls \\\\\\n --json-instances input.json \\\\\\n --version swivel\\n\\n%%writefile input.json\\n{\\\"text\\\": \\\"Scrollability\\\"}\\n\\n!gcloud ai-platform predict \\\\\\n --model txtcls \\\\\\n --json-instances input.json \\\\\\n --version swivel\\n\\n%%writefile input.json\\n{\\\"text\\\": \\\"iOS 14 lets deaf users set alerts for important sounds, among other clever accessibility perks\\\"}\\n\\n!gcloud ai-platform predict \\\\\\n --model txtcls \\\\\\n --json-instances input.json \\\\\\n --version swivel\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"1 line, that's how easy it is to load a csv file using pandas! Next, we will be processing the data to make it easier to work with.\\nProcessing Data\\nAs you can see, the column names are odd and meaningless without prior knowledge of the dataset. To help with that, here is a list describing what each column represents:\\n| Column name | Description |\\n| :------------------------ | :--------- |\\n| SC_Group_ID | # ID of data group |\\n| SC_Group_Desc | description of data group |\\n| SC_GroupCommod_ID | # ID of commodity group |\\n| SC_GroupCommod_Desc | description of commodity group |\\n| SC_Geography_ID | # ID of data location |\\n| SortOrder | weighted sort order by country? unsure |\\n| SC_GeographyIndented_Desc | description of location |\\n| SC_Commodity_ID | # ID of specific commodity type |\\n| SC_Commodity_Desc | description of specific commodity type |\\n| SC_Attribute_ID | # ID of data's attribute |\\n| SC_Attribute_Desc | description of data's attribute |\\n| SC_Unit_ID | # ID of unit type |\\n| SC_Unit_Desc | description of unit type |\\n| Year_ID | year the data represents |\\n| SC_Frequency_ID | # ID of frequency data is collected |\\n| SC_Frequency_Desc | description of frequency data is collected |\\n| Timeperiod_ID | # ID of timeperiod the data represents |\\n| Timeperiod_Desc | description of timeperiod the data represents |\\n| Amount | amount of units describing the attribute for the given commodity type |\\nNote that 'commodity' is asynchronous to grain for the most part. Since the data includes products such as malted barley and alcohol, which aren't grains, we will use 'commodity'. \\nYou probably realized that there are two columns describing each column (the ID and description). To make it easier to work with and shrink the width of the table, we will now delete all the 'duplicate' ID columns by using the...\\n\",\"targets\":\"del df['SC_Group_ID']\\ndel df['SC_GroupCommod_ID']\\ndel df['SortOrder']\\ndel df['SC_Geography_ID']\\ndel df['SC_Commodity_ID']\\ndel df['SC_Attribute_ID']\\ndel df['SC_Unit_ID']\\ndel df['SC_Frequency_ID']\\ndel df['Timeperiod_ID']\\ndf.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create a new dictionary with the following structure and then export as a json object:\\n{user id: [review, review, review], ..., user id: [review, review, review]}\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nuserreview = {}\\n\\nfor i in tqdm.tqdm(range(0,len(biguser[0:20]))):\\n ulist = []\\n for obj in reviews.find({'user_id':biguser[i]}):\\n del obj['_id']\\n ulist.append(obj)\\n userreview[str(biguser[i])] = ulist\\n\\nwith open('user_review_dictionary.json', 'w') as outfile:\\n json.dump(userreview, outfile)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Challenge Exercise\\nCan you compare the following algorithms to see which one performs best?\\n\\nRandomForestRegressor\\nGradientBoostingRegressor\\nAdaBoostRegressor\\nExtraTreesRegressor\\n\\nStatistical Practices\\nHere, I will show you how to use the ShuffleSplit iterator, alongside the cross_val_score method, to evaluate the performance of different regressor models.\\nThe methods here aren't limited to regression, though. You can easily implement these for classification as well.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncv = ShuffleSplit(n=len(X), n_iter=10, test_size=0.3)\\n\\nmodels = dict()\\nmodels['rf'] = RandomForestRegressor()\\nmodels['gb'] = GradientBoostingRegressor()\\nmodels['ad'] = AdaBoostRegressor()\\nmodels['ex'] = ExtraTreesRegressor()\\n\\nscores = dict()\\n\\nfor abbr, model in models.items():\\n print(abbr, model)\\n score = cross_val_score(model, X, Y, cv=cv, scoring='mean_squared_error')\\n scores[abbr] = -score # a known issue in the scikit-learn package; we have to take the negative of the result.\\n\\n\\nscore_summary = pd.DataFrame(scores)\\nscore_summary = pd.DataFrame(score_summary.unstack()).reset_index()\\n# sns.violinplot(x=)\\nscore_summary.columns = ['model', 'idx', 'error']\\nsns.violinplot(x='model', y='error', data=score_summary)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Check to see if the dataset called \\\"patents\\\" exists in the current project. If not, create it.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom google.cloud import bigquery\\n\\n\\nclient = bigquery.Client()\\n\\n# Collect datasets and project information\\ndatasets = list(client.list_datasets())\\nproject = client.project\\n\\n# Create a list of the datasets. If the 'patents' dataset \\n# does not exist, then create it.\\nif datasets:\\n all_datasets = []\\n for dataset in datasets:\\n all_datasets.append(dataset.dataset_id)\\nelse:\\n print('{} project does not contain any datasets.'.format(project))\\n\\nif datasets and 'patents' in all_datasets:\\n print('The dataset \\\"patents\\\" already exists in project {}.'.format(project))\\nelse:\\n dataset_id = 'patents'\\n dataset_ref = client.dataset(dataset_id)\\n\\n # Construct a Dataset object.\\n dataset = bigquery.Dataset(dataset_ref)\\n\\n # Specify the geographic location where the dataset should reside.\\n dataset.location = \\\"US\\\"\\n\\n # Send the dataset to the API for creation.\\n dataset = client.create_dataset(dataset) # API request\\n print('The dataset \\\"patents\\\" was created in project {}.'.format(project))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"NLP\\/03-Natural_language_generation\\/src\\/03_Alice_NLP_generator.ipynb\\\".\\nThe first task is:\\nMaking X boolean (false) array with a shape of the length of the sentences by the step (40) by the length of the unique characters\\/punctuation in the document.\\nMaking y boolean (false) array with a shape of the length of the sentences by the length of the unique characters\\/punctuation in the document.\\nThen, going through each sentence and character in the sentence, storing a 1 (converting false to true) in the respective sentence and characters in X and y.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint('Vectorization...')\\nX = np.zeros((len(sentences), maxlen, len(chars)), dtype=np.bool)\\ny = np.zeros((len(sentences), len(chars)), dtype=np.bool)\\nfor i, sentence in enumerate(sentences):\\n for t, char in enumerate(sentence):\\n X[i, t, char_indices[char]] = 1\\n y[i, char_indices[next_chars[i]]] = 1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Contourplots si heatmaps folosind seaborn\\n\",\"targets\":\"import seaborn as sb\\nimport scipy.stats as st\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Burgers.ipynb\\\".\\nThe first task is:\\nThis geometric reasoning provides a nice intuition for the shock location, but is cumbersome in practice. To determine the location of the shock we can use the Rankine-Hugoniot jump condition, which we will derive in Traffic_flow, and which requires that the jump in flux across a propagating shock must be related to the jump in $q$ by\\n$$\\ns(q_r-q_\\\\ell) = f(q_r) - f(q_\\\\ell),\\n$$\\nat each instant in time, where $s$ is the shock speed at this time. \\nSince the flux for Burgers' equation is $f(q) = q^2\\/2$, this gives\\n\\\\begin{align}\\ns(q_r-q_\\\\ell) & = \\\\frac{1}{2} (q_r^2 - q_\\\\ell^2) \\\\\\n\\\\Rightarrow \\\\ \\\\ \\\\ \\\\ s &= \\\\frac{1}{2}(q_\\\\ell + q_r).\\n\\\\end{align}\\nIn general (as in the image above) the states $q_\\\\ell$ and $q_r$ just to the left and right of the shock will not be constant and the speed of a shock will change in time.\\nShock solution\\nFor Burgers' equation, (or any scalar hyperbolic conservation law with a convex flux function, such as the traffic flow problem considered in Traffic_flow), the solution of the Riemann problem consists of a single wave, which may be either a shock or a rarefaction, separating regions of constant value $q_\\\\ell$ and $q_r$. Here convexity of the flux $f(q)$ means that $f'(q)$ is either monotonically increasing or monotonically decreasing as $q$ varies. If $f(q)$ is not convex then the solution can be more complicated; see the section on Convexity below and in Nonconvex_scalar.\\nThe analysis above already yields the solution to the Riemann problem in the case that the resulting wave is a shock. The entropy condition, as we will explain below, indicates that a shock will form when $f'(q_\\\\ell) > f'(q_r)$; i.e. when $q_\\\\ell>q_r$. In this case, the solution is \\n\\\\begin{align}\\nq(x,t) = \\n\\\\begin{cases}\\nq_\\\\ell \\\\quad \\\\text{if} \\\\ \\\\ x\\/ts.\\n\\\\end{cases}\\n\\\\end{align}\\nBelow, we plot the solution of Burgers' equation for an initial condition that leads to a shock (i.e. with $q_\\\\ell>q_r$).\\nCan you write Python code for it?\\n\",\"targets\":\"\\ninteract(burgers_demos.shock(), \\n t=widgets.FloatSlider(min=0,max=1.0,value=0.5),\\n which_char=widgets.Checkbox(value=True,\\n description='Show characteristics'));\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#def is_good_output_dictionary(output_words):\\n# return np.array(\\n# [ (1.0 if w in wordset else 0.0) for w in output_words ],\\n# dtype='float32'\\n# )\\n\\ndef is_good_output_discriminator(output_words):\\n disc_input_values, disc_mask_values = prep_batch_for_network(output_words)\\n disc_output_, = disc_predict(disc_input_values, disc_mask_values)\\n \\n return disc_output_.reshape( (-1,) )\\n\\nreset_generative_network()\\ntrain_generative_network(is_good_output_function=is_good_output_discriminator, epochs=1*1000, bigram_overlay=0.9)\\n#train_generative_network(is_good_output_function=is_good_output_dictionary, epochs=1*1000, bigram_overlay=0.9)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUse training signal from Discriminator\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Access the reference set\\nThe GA4GH Genomics API provides methods for accessing the bases of a reference. The Thousand Genomes data presented here are mapped to GRCh37.\\nTo access these data we first list the reference sets.\\n\",\"targets\":\"referenceSet = c.searchReferenceSets().next()\\nprint(referenceSet)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"$ \\\\frac { d\\\\vec{R_1} } { d\\\\alpha_2} = -\\\\frac {1}{R} \\\\frac {1}{1-\\\\frac{\\\\alpha_2}{R}} \\\\vec{R_1} $\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndR2dalpha1 = trigsimp(R2.diff(alpha1))\\ndR2dalpha1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"(An even simpler) variation on the basic example\\n\",\"targets\":\"df = pd.DataFrame(\\n np.array([[1.], [3.], [5.], [9.], [10.]]),\\n columns=['A'])\\n\\nsignatures.signature(df, max_word_length=5)\\n\\ndf = pd.DataFrame(\\n np.array([[1.], [3.], [2.], [-9.], [10.]]),\\n columns=['A'])\\n\\nsignatures.signature(df, max_word_length=5)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# the true label (in this case, 2) from our dataset wrapped\\n# as a tensor of minibatch size of 1\\ny_gold = torch.tensor([1])\\n\\n# our simple classification criterion for this simple example\\ncriterion = nn.CrossEntropyLoss()\\n\\n# forward pass of our model (remember, using apply instead of forward)\\ny = model(x)\\n\\n# apply the criterion to get the loss corresponding to the pair (x, y)\\n# with respect to the real y (y_gold)\\nloss = criterion(y, y_gold)\\n\\n\\n# the loss contains a gradient function that we can use to compute\\n# the gradient dL\\/dw (gradient with respect to the parameters\\n# for a given fixed input)\\nprint(loss)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCriteria and loss functions\\nPyTorch has implementations for the most common criteria in the torch.nn package. You may notice that, as with many of the other functions, there are two implementations of loss functions: the reference functions in torch.nn.functional and practical class in torch.nn, which are the ones we typically use. Probably the two most common ones are (Lapan 2018):\\n\\nnn.MSELoss (mean squared error): squared $L_2$ norm used for regression.\\nnn.CrossEntropyLoss: criterion used for classification as the result of combining nn.LogSoftmax() and nn.NLLLoss() (negative log likelihood), operating on the input scores directly. When possible, we recommend using this class instead of using a softmax layer plus a log conversion and nn.NLLLoss, given that the LossSoftmax implementation guards against common numerical errors, resulting in less instabilities.\\n\\nOnce our model produces a prediction, we pass it to the criteria to obtain a measure of the loss:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"3.5.3 Septemer 2014\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nplot_month(df, (2014, 9), kind='contour', normed=True, bins=np.arange(0, 10, 1), cmap=cm.RdYlBu_r)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Practice: Perform mini batch gradient descent with a batch size of 20.\\n\\ndataset = Data()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n\\n\\nPractice<\\/h3>\\n\\nPerform mini batch gradient descent with a batch size of 20. Store the total loss for each epoch in the list LOSS20.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create a data loader object and set the batch_size to 5:\\n\",\"targets\":\"train_loader=DataLoader(dataset=data_set,batch_size=5)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3: unit\\/systems stripe-docs-test\\nThree terms, A,B,C and their corresponding stripe-docs of co-occurring terms\\n\\nDocA {X:20, Y:30, Z:5}\\nDocB {X:100, Y:20}\\nDocC {M:5, N:20, Z:5}\\n\",\"targets\":\"############################################\\n# Stripes for systems test 1 (predefined)\\n############################################\\n\\nwith open(\\\"mini_stripes.txt\\\", \\\"w\\\") as f:\\n f.writelines([\\n '\\\"DocA\\\"\\\\t{\\\"X\\\":20, \\\"Y\\\":30, \\\"Z\\\":5}\\\\n',\\n '\\\"DocB\\\"\\\\t{\\\"X\\\":100, \\\"Y\\\":20}\\\\n', \\n '\\\"DocC\\\"\\\\t{\\\"M\\\":5, \\\"N\\\":20, \\\"Z\\\":5, \\\"Y\\\":1}\\\\n'\\n ])\\n!cat mini_stripes.txt\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"As you've probably heard, Euclidean distance is not an ideal choice for any sparse data (also this). That's because when we vectorize a corpus, we end up with huge, sparse vectors. That means that it's sort of a crapshoot as to whether the most informative features (e.g. words) will vary in a way that will be captured by Euclidean distance. We can see in the above that Euclidean distance hasn't done a terrible job of spacially differentiating the different categories of documents; the \\\"sports\\\" and \\\"cooking\\\" clusters look pretty clear. However there's a lot of overlap and muddling of the other categories.\\nThis makes more sense when we think in terms of informative features, which in the case of text are words. Some of the most informative features in the cooking category might occur only in a chunk of the corpus, others (maybe words from the \\\"cinema\\\" and \\\"gaming\\\" categories) might be spread out through the whole corpus, but more frequently in some documents than others. Some of our documents might be really long, while others are short, which means they'll be hard to compare; the short one will have a much more sparse vector representation.\\nWhat to do?\\nDistance Metrics for Non-numerical Inputs\\nPer sklearn:\\n\\\"scikit-learn estimators assume you’ll feed them real-valued feature vectors. This assumption is hard-coded in pretty much all of the library. However, you can feed non-numerical inputs to estimators in several ways.\\\"\\nIn our case, the sklearn.manifold.TSNE has a metric param that will allow us to leverage any of the distance metrics available in Scipy!\\nWe could try them all!\\n```\\ndistance_functions = [\\n \\\"braycurtis\\\", \\\"canberra\\\", \\\"chebyshev\\\", \\\"cityblock\\\", \\\"correlation\\\", \\\"cosine\\\", \\n \\\"dice\\\", \\\"euclidean\\\", \\\"hamming\\\", \\\"jaccard\\\", \\\"kulsinski\\\", \\\"mahalanobis\\\", \\n \\\"matching\\\", \\\"minkowski\\\", \\\"rogerstanimoto\\\", \\\"russellrao\\\", \\\"seuclidean\\\", \\n \\\"sokalmichener\\\", \\\"sokalsneath\\\", \\\"sqeuclidean\\\", \\\"yule\\\"\\n]\\nfor metric in distance_functions:\\n tsne = TSNEVisualizer(metric=metric)\\n tsne.fit(docs, labels)\\n ...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntsne = TSNEVisualizer(metric=\\\"cityblock\\\")\\ntsne.fit(docs, labels)\\ntsne.poof()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"An alternative to grid search: randomized search\\nGrid search is quite commonly used, but another way to search through hyperparameter space to find optima is by using randomized search. With randomized search, we don't build a grid of HP values we want to try out. Instead, we specify the regions of hyperparameter space we are interested in by specifying distributions that we want to sample from. Importantly, we also specify a computational budget (n_iter) which controls the number of HP combinations we will test out using CV. So, rather than the brute force approach of grid search, where we are forced to try out every combination, we can trade off between the computational resources we want to spend and the chances that we'll find the optimal combination of HP values. But because we prespecify regions where we think the correct HP values will lie, we are likely to cover some good possibilities even with a modest computational budget.\\nThere is evidence that randomized search is more efficient than grid search, because grid search effectively wastes time by exhaustively checking each option when it might not be necessary. By contrast, the random experiments utilized by randomized search can explore the important dimensions of hyperparameter space with more coverage. If we were to use uniform distributions for all of our HPs and allow as many sampling iterations as there are combinations of the HPs, then randomized search just becomes grid search. \\nTo use randomized search to tune random forests, we first specify the HP distributions:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom scipy.stats import uniform\\nfrom scipy.stats import norm\\n\\nfrom sklearn.grid_search import RandomizedSearchCV\\n\\n# Designate distributions to sample hyperparameters from \\n# Uniform distribution for n_estimators, Gaussian for max_features\\nn_estimators = np.random.uniform(25, 45, 5).astype(int)\\nmax_features = np.random.normal(20, 10, 5).astype(int)\\n\\nhyperparameters = {'n_estimators': list(n_estimators),\\n 'max_features': list(max_features)}\\n\\nprint hyperparameters\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Get the data\\nfrom io import StringIO \\nmovie_txt = requests.get('https:\\/\\/raw.github.com\\/cs109\\/cs109_data\\/master\\/movies.dat').text\\nmovie_file = StringIO(movie_txt) # treat a string like a file\\nmovies = pd.read_csv(movie_file, delimiter='\\\\t')\\nmovies = movies.dropna()\\nmovies = movies.reset_index(drop = True)\\n\\n# process data\\ndata = movies[['year','rtTopCriticsRating']]\\n#data = data.convert_objects(convert_numeric=True) #deprecated\\ndata = data.apply(pd.to_numeric)\\ndata = data[(data.rtTopCriticsRating > 0.00)]\\nmeans = data.groupby('year').mean()\\n\\n# plotting\\nplt.plot(data['year'], data['rtTopCriticsRating'], 'o', mec = 'none', alpha = .5, label = 'Data' )\\nplt.plot(means.index, means['rtTopCriticsRating'], '-', label = 'Yearly Average' )\\nplt.legend(loc ='lower left', frameon = False)\\nplt.xlabel(\\\"Year\\\")\\nplt.ylabel(\\\"Average Score\\\")\\nremove_border()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUsing the original movies dataframe, plot the rotten tomatoes Top Critics Rating as a function of year. Overplot the average for each year, ignoring the score=0 examples (some of these are missing data).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# prose stats\\nsentences = list(filter(lambda x : len(x)>0, map(str.strip, re.split(r'[\\\\.\\\\?!\\\\n]', text))))\\nsen_len = [len(sent) for sent in sentences]\\nprint(\\\"Average sentence len {}. Max {}, min {}\\\".format(np.mean(sen_len), max(sen_len), min(sen_len)))\\n\\nfor sent in sentences:\\n if len(sent)>300:\\n print(\\\"* \\\" + sent)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nProse Stats\\n“Over the whole document, make the average sentence length 15-20 words, 25-33 syllables and 75-100 characters.”\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"6) Where are the protected areas in South America? (Part 2)\\nCreate a plot that uses the protected_areas GeoDataFrame to show the locations of the protected areas in South America. (You'll notice that some protected areas are on land, while others are in marine waters.)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Country boundaries in South America\\nsouth_america = americas.loc[americas['continent']=='South America']\\n\\n# Your code here: plot protected areas in South America\\n____\\n\\n# Uncomment to see a hint\\n#_COMMENT_IF(PROD)_\\nq_6.hint()\\n\\n#%%RM_IF(PROD)%%\\n# Plot protected areas in South America\\nax = south_america.plot(figsize=(10,10), color='white', edgecolor='gray')\\nprotected_areas.plot(ax=ax, alpha=0.4)\\n\\n# Get credit for your work after you have created a map\\nq_6.check()\\n\\n# Uncomment to see our solution (your code may look different!)\\n#_COMMENT_IF(PROD)_\\nq_6.solution()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Colormap reference: http:\\/\\/matplotlib.org\\/examples\\/color\\/colormaps_reference.html\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfig, ax = plt.subplots(1,5,sharey=True)\\n\\nfig.set_size_inches(12,6)\\n\\nfig.tight_layout()\\n\\nax[0].imshow(I, cmap=plt.cm.viridis)\\nax[0].set_xlabel('viridis')\\n\\nax[1].imshow(I, cmap=plt.cm.hot)\\nax[1].set_xlabel('hot')\\n\\nax[2].imshow(I, cmap=plt.cm.magma)\\nax[2].set_xlabel('magma')\\n\\nax[3].imshow(I, cmap=plt.cm.spectral)\\nax[3].set_xlabel('spectral')\\n\\nax[4].imshow(I, cmap=plt.cm.gray)\\nax[4].set_xlabel('gray')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Any of the 1-D fields (ie not vertices or normals) or matplotlib-recognized colornames can be used to color either the faces or edges of the triangles. Passing none for edgecolor or facecolor turns off the coloring (you may want to set edgecolor=None if setting facecolor to disable the black outline).\\n\",\"targets\":\"afig, mplfig = b.plot(fc='teffs', ec='None', show=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Challenge\\n1. Draw multiple graphs\\nWrite a code that collects the first 3 filenames from the list obtained by\\n\",\"targets\":\"glob.glob('*.csv')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Get model resource ID\\nmodels = aip.Model.list(filter=\\\"display_name=gsod_\\\" + TIMESTAMP)\\n\\n# Get a reference to the Model Service client\\nclient_options = {\\\"api_endpoint\\\": f\\\"{REGION}-aiplatform.googleapis.com\\\"}\\nmodel_service_client = aip.gapic.ModelServiceClient(client_options=client_options)\\n\\nmodel_evaluations = model_service_client.list_model_evaluations(\\n parent=models[0].resource_name\\n)\\nmodel_evaluation = list(model_evaluations)[0]\\nprint(model_evaluation)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nReview model evaluation scores\\nAfter your model has finished training, you can review the evaluation scores for it.\\nFirst, you need to get a reference to the new model. As with datasets, you can either use the reference to the model variable you created when you deployed the model or you can list all of the models in your project.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Calculate Likelihood\\nRemember that each term (e.g. $p(\\\\text{height}\\\\mid\\\\text{female})$) in our likelihood is assumed to be a normal pdf. For example:\\n$$ \\np(\\\\text{height}\\\\mid\\\\text{female})=\\\\frac{1}{\\\\sqrt{2\\\\pi\\\\text{variance of female height in the data}}}\\\\,e^{ -\\\\frac{(\\\\text{observation's height}-\\\\text{average height of females in the data})^2}{2\\\\text{variance of female height in the data}} }\\n$$\\nThis means that for each class (e.g. female) and feature (e.g. height) combination we need to calculate the variance and mean value from the data. Pandas makes this easy:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Group the data by gender and calculate the means of each feature\\ndata_means = data.groupby('Gender').mean()\\n\\n# View the values\\ndata_means\\n\\n# Group the data by gender and calculate the variance of each feature\\ndata_variance = data.groupby('Gender').var()\\n\\n# View the values\\ndata_variance\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%opts Image (cmap='gray')\\nhv.Image(r,label=\\\"R\\\") + hv.Image(g,label=\\\"G\\\") + hv.Image(b,label=\\\"B\\\")\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nYou can see how the RGB object is created from the original channels:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Comparing original dataset with augmented images\\n\",\"targets\":\"# Train model with augmented data\\n\\ndef evaluate_model(model, datagen, \\n X_tr, y_tr, X_te, y_te, \\n optimizer, batch=256, epochs=20, verbose=False):\\n \\\"\\\"\\\"\\n Wrapper method to create, train and optionally CV, and check performance on test set\\n \\\"\\\"\\\"\\n\\n if verbose:\\n print('\\\\nCompiling model')\\n model.summary()\\n \\n model.compile(optimizer=optimizer,\\n loss='categorical_crossentropy', \\n metrics=['accuracy'])\\n \\n if verbose:\\n print('\\\\nTraining model (no image augmentation)')\\n\\n # Only difference is now the generator provides flow of images for minibatches\\n history = model.fit_generator(datagen.flow(X_tr, y_tr, batch_size=batch),\\n steps_per_epoch=int(X_tr.shape[0] \\/ batch), epochs=epochs, \\n verbose=1 if verbose else 0)\\n \\n if verbose:\\n print('\\\\nEvaluating model')\\n \\n train_score = model.evaluate(X_tr, y_tr, batch_size=batch)\\n test_score = model.evaluate(X_te, y_te, batch_size=batch)\\n\\n if verbose:\\n print('\\\\nTest results: Loss = {:.2f}, Error = {:.2f}'.format(100.0 * test_score[0], 100.0 * (1.0 - test_score[1])))\\n \\n results = {'model': model, 'history': history.history, \\n 'train_loss': train_score[0], 'train_acc': train_score[1], 'train_err': 1.0 - train_score[1],\\n 'test_loss': test_score[0], 'test_acc': test_score[1], 'test_err': 1.0 - test_score[1],\\n }\\n return results\\n\\n\\n\\n# Do a run with no augmentation for a baseline\\n\\nN = 1\\n\\ndatagen_std = ImageDataGenerator(\\n featurewise_center=True,\\n featurewise_std_normalization=True\\n)\\n\\ndatagen_std.fit(X_train)\\n\\nresults = np.zeros((N,))\\n\\nfor n in range(N): \\n print('\\\\nEvaluating model {} of {}'.format(n+1, N))\\n\\n result = evaluate_model(lenet5_modern_model(dropout_cnt=best_dropout[0], \\n dropout_val=best_dropout[1]),\\n datagen_std,\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Projects\\/mlt_calib\\/float_Y_float_alpha.ipynb\\\".\\nThe first task is:\\nThese figures nicely illustrate the aforementioned phenomenon that models grow increasingly resiliant to variations in input parameters as stellar mass (and effective temperature) decreases. Note that it should be possible to quantify the significance of any potential rising trend toward lower masses or temperatures with statistical tests, if one so desires.\\nFor the moment, we can look how the tunable parameters vary. Starting with helium abundance,\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfig, ax = plt.subplots(2, 2, figsize=(12, 12), sharey=True)\\n\\nax[0, 0].set_xlabel('Mass (M$_{\\\\\\\\odot}$)', fontsize=20.)\\nax[0, 1].set_xlabel('Effective Temperature (K)', fontsize=20.)\\nax[1, 0].set_xlabel('Heavy Element Mass Fraction, $Z_i$', fontsize=20.)\\nax[1, 1].set_xlabel('Mixing Length Parameter', fontsize=20.)\\nax[1, 0].set_ylabel('Helium Mass Fraction, $Y_i$', fontsize=20.)\\nax[0, 0].set_ylabel('Helium Mass Fraction, $Y_i$', fontsize=20.)\\n\\nfor x in ax:\\n for y in x:\\n y.tick_params(which='major', axis='both', length=10., labelsize=16.)\\n\\nZ_init = (1.0 - data[:, 2])\\/(10.0**(-1.0*(data[:, 1] + np.log10(0.026579))) + 1.0) \\n\\n# Helium abundance variation\\nax[0, 0].plot(data[:, 0], data[:, 2], 'o', markersize=9.0, color='#4682B4')\\nax[1, 0].plot(Z_init, data[:, 2], 'o', markersize=9.0, color='#4682B4')\\nax[0, 1].plot(data[:,24], data[:, 2], 'o', markersize=9.0, color='#4682B4')\\nax[1, 1].plot(data[:, 5], data[:, 2], 'o', markersize=9.0, color='#4682B4')\\n\\nfig.tight_layout()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Create a custom evalution metric\\ndef rmse(y_true, y_pred):\\n return # TODO: Your code here\\n\\n\\n# Compile the keras model\\n# TODO: Your code here\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNext, to prepare the model for training, you must configure the learning process. This is done using the compile method. The compile method takes three arguments:\\n\\nAn optimizer. This could be the string identifier of an existing optimizer (such as rmsprop or adagrad), or an instance of the Optimizer class.\\nA loss function. This is the objective that the model will try to minimize. It can be the string identifier of an existing loss function from the Losses class (such as categorical_crossentropy or mse), or it can be a custom objective function.\\nA list of metrics. For any machine learning problem you will want a set of metrics to evaluate your model. A metric could be the string identifier of an existing metric or a custom metric function.\\n\\nWe will add an additional custom metric called rmse to our list of metrics which will return the root mean square error. \\nExercise. Compile the model you created above. Create a custom loss function called rmse which computes the root mean squared error between y_true and y_pred. Pass this function to the model as an evaluation metric.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"03-NumPy-and-Linear-Algebra\\/Introduction_class.ipynb\\\".\\nThe first task is:\\nMultiple Linear Regression\\nCan you write Python code for it?\\n\",\"targets\":\"\\nn = 100 # numeber of samples\\nX1 = np.random.rand(n)*99.0\\nX2 = np.random.rand(n)*51.0 - 26.8\\nX3 = np.random.rand(n)*5.0 + 6.1\\nX4 = np.random.rand(n)*1.0 - 0.5\\nX5 = np.random.rand(n)*300.0\\n\\ny_m = -7.3 + 2.5*X1 + -7.9*X2 + 1.5*X3 + 10.0*X4 + 0.13*X5 + np.random.randn(n)*7.0\\nplt.hist(y_m, bins=20)\\n;\\n\\nX_m = np.vstack((np.ones(n), X1, X2, X3, X4, X5)).T\\nX_m.shape\\n\\nbeta_m = np.linalg.inv(X_m.T.dot(X_m)).dot(X_m.T).dot(y_m)\\nbeta_m\\n\\nyhat_m = X.dot(beta_m)\\nyhat_m.shape\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Old_Runs\\/tutorial_6slices.ipynb\\\".\\nThe first task is:\\nNow let's overplot the reddening profiles corresponding to our most probable parameters on top of the stacked stellar posterior surfaces. We show two options. The first plot has been normalized so that a) each individual stellar posterior array sums to one and b) each distance column in the stacked posterior array contains the same amount of \\\"ink.\\\" The second plot just normalized so each individual stellar posterior array sums to 1. Each colored reddening profile corresponds to a single pixel in the Dame et al. 2001 CO spectral cube. There are stars in ~175 Dame et al. 2001 CO pixels in our region of interest.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom dustcurve import pixclass\\n\\npost_all=np.empty((0,700,120))\\n\\nfor i in range(0,len(gv.unique_post)):\\n post_all=np.vstack((post_all,gv.unique_post[i]))\\n \\n#from dustcurve import plot_posterior\\n#plot the reddening profile over the stacked, normalized stellar posterior surfaces \\n#normcol=True, normsurf=True\\n#plot_posterior.plot_posterior(np.asarray(post_all),np.linspace(4,19,120),np.linspace(0,7,700),quantile_50,ratio,gv.unique_co,y_range=[0,2],vmax=0.03,normcol=True)\\n#plot_posterior.plot_posterior(np.asarray(post_all),np.linspace(4,19,120),np.linspace(0,7,700),quantile_50,ratio,gv.unique_co,y_range=[0,2],vmax=10.0,normcol=False)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Betweenness avg adopters and seed\\n\",\"targets\":\"bet_mean = np.mean(bet[:,1])\\nbet_mean_seed = np.mean(bet[:,0])\\nprint 'Avg Seed:',bet_mean_seed, 'Avg adopters:',bet_mean\\n\\ndraw_avgs([pr_mean, eigen_mean, bet_mean])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Asymptotic behaviors and approximations\\nWe can try to approximate the solution for small $a$ or large $a$:\\n\\n\\nFor small $a$, $W(2a) \\\\simeq 2a - 4a^2$ so $x(a) \\\\simeq 1 - a$.\\n\\n\\nFor large $a$, we have this bound:\\n $$ \\\\forall x \\\\geq \\\\mathrm{e},{\\\\displaystyle \\\\ln(x)-\\\\ln {\\\\bigl (}\\\\ln(x){\\\\bigr )}+{\\\\frac {\\\\ln {\\\\bigl (}\\\\ln(x){\\\\bigr )}}{2\\\\ln(x)}}\\\\leq W(x)\\\\leq \\\\ln(x)-\\\\ln {\\\\bigl (}\\\\ln(x){\\\\bigr )}+{\\\\frac {e}{e-1}}{\\\\frac {\\\\ln {\\\\bigl (}\\\\ln(x){\\\\bigr )}}{\\\\ln(x)}}} $$\\n\",\"targets\":\"e = np.exp(1)\\n\\ndef upper_bound(a):\\n up_b = np.log(2*a) - np.log(np.log(2*a)) + (e \\/ (e - 1)) * (np.log(np.log(2*a)) \\/ np.log(2*a))\\n return np.sqrt(up_b \\/ (2*a))\\n\\ndef lower_bound(a):\\n lo_b = np.log(2*a) - np.log(np.log(2*a)) + np.log(np.log(2*a)) \\/ (2 * np.log(2*a))\\n return np.sqrt(lo_b \\/ (2*a))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Basic manipulations\\nmatvec\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmatrix_from_list.dot(vector_from_list)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Code here\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n2.5 Visualize the coefficients for LogisticRegression and Linear Support Vector Machines.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#NBVAL_IGNORE_OUTPUT\\nax = plot_meniscus(target_Pc=touch_Pc, meniscus_model=circular_model)\\nax.plot([max_bulge, max_bulge], [-throatRad, throatRad], 'r--');\\n\\n#NBVAL_IGNORE_OUTPUT\\nax = plot_meniscus(target_Pc=max_Pc_circle, meniscus_model=circular_model)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe can see that the touch_Pc calculated earlier, corresponds with the tip of the meniscus exceeding the max_bulge parameter. Try changing this and re-running to see what happens.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Lesson05_Strings\\/Strings.ipynb\\\".\\nThe first task is:\\nTRY IT\\nCreate a string with your name and store it in a variable called name. Print the last character of your name using both indexing methods (positive and negative).\\nString Slices\\nYou can take more than a single character; you can take a whole slice. To take a slice, give the first index and then the last index + 1. (The first index is inclusive, second index is exclusive)\\nstring[0:5]\\nCan you write Python code for it?\\n\",\"targets\":\"\\nsecond_animal = chinese_zodiac[4:6]\\nprint(second_animal)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%matplotlib inline\\nimport numpy as np\\nimport ndmg.nuis.nuis as ndn # nuisance correction scripts\\nimport matplotlib.pyplot as plt\\nimport nibabel as nb\\nimport scipy.fftpack as scifft\\nfrom sklearn.metrics import r2_score\\n\\nL = 200\\ntr = 2 # the tr of our data\\nt = np.linspace(0, L-1, L) # generate time steps\\nstim_freq = .1\\n\\nstim = np.sin(2*np.pi*stim_freq*t*tr) # generate our stimulus timeseries\\n\\n\\n# generate coefficients for linear model\\nw = np.array([.75, -.01, .00005])\\nw = np.expand_dims(w, 1)\\n\\nconst = np.ones((L,1))\\nlin = np.array(range(0, L))\\nquad = np.array(range(0, L))**2\\n\\n# make a design matrix\\nR = np.column_stack((const, lin, quad))\\n\\nsig = stim.copy()\\nsig = np.expand_dims(sig, 1)\\nsig += R.dot(w)\\n\\n\\nlow_freq = [0.003,0.006]\\nlow_freq_amp = [.2,.1]\\n\\n# add low-frequency drift\\nfor freq, amp in zip(low_freq, low_freq_amp):\\n sig += np.expand_dims(amp*np.sin(2*np.pi*freq*t*tr), 1)\\n\\n\\nfig = plt.figure()\\nax = fig.add_subplot(111)\\nax.plot((t*tr)[0:100], stim[0:100])\\nax.set_xlabel('Timestep')\\nax.set_ylabel('Response')\\nax.set_title('Stimulus before corruption')\\n\\nbef_r2 = r2_score(stim, sig[:,0])\\nfig = plt.figure()\\nax = fig.add_subplot(111)\\nax.plot((t*tr)[0:100], sig[0:100,0])\\nax.set_xlabel('Timestep')\\nax.set_ylabel('Response')\\nax.set_title('Stimulus after corruption, r^2 = ' + str(bef_r2))\\n\\ncorr = ndn().freq_filter(sig, tr, 0.01)\\ncorr = ndn().linear_reg(sig)\\n\\naft_r2 = r2_score(stim, corr[:,0])\\nfig = plt.figure()\\nax = fig.add_subplot(111)\\nax.plot((t*tr)[0:100], corr[0:100,0])\\nax.set_xlabel('Timestep')\\nax.set_ylabel('Response')\\nax.set_title('Stimulus after correction, r^2 = ' + str(aft_r2))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAgain, we can see that we are able to virtually perfectly fit the predicted response, as we increase our $R^2$ from .68 to .999.\\nCombined Check\\nNext, we will do a combined check using the same data from the previous two tests to verify that when we perform fft followed by quadratic detrending, we are again able to recover the expected sinusoid with similar accuracy.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Creating a variable with a variable-length (vlen) data type\\nnetCDF 4 has support for variable-length or \\\"ragged\\\" arrays. These are arrays of variable length sequences having the same type. \\n\\nTo create a variable-length data type, use the createVLType method.\\nThe numpy datatype of the variable-length sequences and the name of the new datatype must be specified.\\n\",\"targets\":\"vlen_t = ncfile.createVLType(np.int64, 'phony_vlen')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"'len' is short for length. When you call it returns how big the object is, in the case of strings, that’s how many characters the string contains. Thus len(“12345”) returns 5.\\n3. Functions with Multiple Arguments\\nFunctions that take multiple arguments can be further defined into those that require exactly n arguments and those functions that can handle an arbitrary number of arguments. We shall briefly cover both. The syntax:\\n{function name} ({argument}, {argument2})\\n\\nSo, to call a function that takes two arguements as imput all we do is type two arguments seperated by a comma. Let's see that in action:\\n\",\"targets\":\"# defining the function...\\ndef multiply(a, b):\\n return a * b # remember '*' is multiplication!\\n\\nmultiply(10, 25) # <-- calling the function with two arguments, 10 and 25\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Sharepa is a python client for browsing and analyzing SHARE data specifically using elasticsearch querying.\\n # We can use this to aggregate, graph, and analyze the data. \\n # Helpful Links:\\n # https:\\/\\/github.com\\/CenterForOpenScience\\/sharepa\\n # https:\\/\\/pypi.python.org\\/pypi\\/sharepa\\n # here, we import the specific function from Sharepa called basic_search\\nfrom sharepa import basic_search\\n\\n# this performs a basic search over the SHARE dataset and returns a count of the items in it\\nbasic_search.count()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUsing SHAREPA for SHARE Parsing and Analysis\\nWhile you can always pass raw elasticsearch queries to the SHARE API, there is also a pip-installable python library that you can use that makes elasticsearch aggregations a little simpler. This library is called sharepa - short for SHARE Parsing and Analysis\\nBasic Actions\\nA basic search will provide access to all documents in SHARE in 10 document slices.\\nCount\\nYou can use sharepa and the basic search to get the total number of documents in SHARE\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Chapter 2 - Stepping up with SciPy.ipynb\\\".\\nThe first task is:\\nOne very nice property of pandas, it that it can be easily used to move around data in a variety of formats (which is what I mainly use it for). Creating a LaTeX representation of this matrix, for instance, is super-easy:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf.to_latex()[:1000]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"CSNE2444-Intro-to-CS-I\\/jupyter-notebooks\\/ch08-strings.ipynb\\\".\\nThe first task is:\\nIn this case, the method upper is called on the string word\\nIt returns a new string with all the letters now in uppercase\\nCalling a method like this is called an invocation\\nStrings in Python have a number of methods already built in\\nOne of them is find\\nIt finds th eindex of a specified substring (not just a character)\\nPython's documentation lists them all \\nhttps:\\/\\/docs.python.org\\/3\\/library\\/stdtypes.html#string-methods\\n\\nThe in operator\\n\\nStrings have an in operator that returns True if the first string is a substring of the second\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint( 'an' in 'banana' )\\nprint( 'seed' in 'banana' )\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\n\\nEXERCISE<\\/b>:\\n\\n \\n Plot the fraction of roles that have been 'actor' roles each year over the whole period of available movie data.<\\/li>\\n<\\/ul>\\n<\\/div>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ngrouped = cast.groupby(['year', 'type']).size()\\ntable = grouped.unstack('type').fillna(0)\\n(table['actor'] \\/ (table['actor'] + table['actress'])).plot(ylim=[0, 1])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"24_Prelab_Python-II\\/Lesson2.ipynb\\\".\\nThe first task is:\\nSince a and b are not both True, the conditional statement \\\"a and b\\\" as a whole is False. Therefore, we execute the else-block.\\nCan you write Python code for it?\\n\",\"targets\":\"\\na = True\\nb = False\\nif a and not b:\\n print \\\"Apple\\\"\\nelse:\\n print \\\"Banana\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Calculo_Error\\/Gravedad_con_distribucion_tstudent_y_normal.ipynb\\\".\\nThe first task is:\\nEl procedimiento del cálculo de la propagación de errores se hizo en el cuaderno de protocolo a partir de la siguiente fórmula:\\n$$\\\\delta g = \\\\frac{2h}{t^2}\\\\big(\\\\frac{\\\\delta (2h)}{2h} + \\\\frac{\\\\delta (t^2)}{t^2}\\\\big)$$\\nDonde\\n$$ \\\\delta (2h) = 2\\\\delta h$$\\n$$\\\\delta (t^2) = 2t\\\\delta t $$\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#Resultados de calculo de propagacion de errores\\n\\ndeltag1 = 25.33 #m\\/s^2\\ndeltag2 = 3.65 #m\\/s^2\\ndeltag3 = 3.39 #m\\/s^2\\n\\nprint ('Gravedad con 5 medidas(t-student) = (%0.3f +\\/- %0.3f) m\\/s2'%(g1,deltag1))\\nprint ('Gravedad con 5 experimentos (3sgima) = (%0.3f +\\/- %0.3f) m\\/s2'%(g2,deltag2))\\nprint ('Gravedad con 30 medidas (3sgima) = (%0.3f +\\/- %0.3f) m\\/s2'%(g3,deltag3))\\n\\n# Graficación de los resultados\\nnumdatos = datos1.size\\nl1 = np.ones(numdatos) # para graficar los datos de cada muestra en una línea\\n\\nplt.figure(figsize=(16,3))\\nplt.axvline(gt,linewidth=3, c=\\\"black\\\",label='Gravedad Teorica')\\nplt.plot([g1-deltag1, g1+deltag1], [1, 1], linewidth=3, linestyle=\\\"-\\\", color=\\\"red\\\",solid_capstyle=\\\"butt\\\",label='Gravedad t-student')\\nplt.plot([g2-deltag2, g2+deltag2], [2, 2], linewidth=3, linestyle=\\\"-\\\", color=\\\"blue\\\",solid_capstyle=\\\"butt\\\",label='Gravedad 5 Experm.')\\nplt.plot([g3-deltag3, g3+deltag3], [3, 3], linewidth=3, linestyle=\\\"-\\\", color=\\\"green\\\",solid_capstyle=\\\"butt\\\",label='Gravedad 30 datos')\\nplt.legend()\\n#plt.xlim(0,1) \\nplt.ylim(0,4)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"PYNQLearn\\/FabricOnly\\/myHDL_PYNQZ12_FabricOnly.ipynb\\\".\\nThe first task is:\\nProject 1: 1 Switch 1 LED\\nhttps:\\/\\/timetoexplore.net\\/blog\\/arty-fpga-verilog-01\\nConstraints File\\nmyHDL Code\\nCan you write Python code for it?\\n\",\"targets\":\"\\n@block\\ndef S0L0(sw, clk, led):\\n \\\"\\\"\\\"\\n FPGA Hello world of one switch controlling one LED based on\\n https:\\/\\/timetoexplore.net\\/blog\\/arty-fpga-verilog-01\\n \\n Target:\\n ZYNQ 7000 Board (Arty, PYNQ-Z1, PYNQ-Z2) with at least 2 \\n switchs and 4 leds\\n \\n \\n Input:\\n sw(2bitVec):switch input\\n clk(bool): clock input \\n Ouput:\\n led(4bitVec): led output\\n \\n \\\"\\\"\\\"\\n \\n @always(clk.posedge)\\n def logic():\\n if sw[0]==0:\\n led.next[0]=True\\n else:\\n led.next[0]=False\\n \\n return instances()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"05其他\\/pandas文档-zh-master\\/与SQL对比-Comparison with SQL.ipynb\\\".\\nThe first task is:\\n连接\\n使用join()或merge()进行连接。默认情况下,join()将加入DataFrames索引。每个方法有参数允许您指定连接类型(LEFT, RIGHT, INNER, FULL)或列的连接(列名或索引)。\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],\\n 'value': np.random.randn(4)})\\n\\ndf2 = pd.DataFrame({'key': ['B', 'D', 'D', 'E'],\\n 'value': np.random.randn(4)})\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!pytest --cov\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nRun the tests and check code coverage\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Question\\nplt.imshow(image[ # complete\\n # complete\\n )\\nplt.axvline(x_center, color='r')\\nplt.axhline(y_center, color='r')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nDo the values you got make sense? Are they within the range of x and y coordinate values of the cutout? Does it roughly match where the star is? If not, are they possibly swapped, x-for-y and y-for-x? (It's very easy to get confused with the ordering of x and y indicies in Numpy, I make that mistake all the time).\\nIf they make sense, try overplotting the coordinates on one of your larger cutout images.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# sort data (axis = 0: sort along model results!)\\nmssort = np.sort(model_sections, axis = 0)\\n# create difference matrix\\nmssort_diff = mssort[1:,:,:] - mssort[:-1,:,:]\\n\\nn_samples = model_sections.shape[0]\\n# and now: for all!\\nh = np.empty_like(mssub[0,:,:])\\nfor i in range(100):\\n for j in range(40):\\n h[i,j] = entropy(mssort_diff[:,i,j], n_samples)\\nh[50,30]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe algorithm works on the simple idea that we do not explicitly require the single outputs at each location, but only the relative probability values. This may not matter too much for single entropy estimates (uni-variate), but it will matter a lot for multivariate cases, because we do not need to check all possible outcomes! Note that all outcomes with zero probability are simply not considered in the sorting algorithm (and they do not play any role in the calculation of the entropy, anyway), and that's exactly what we want to have!\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Hint 下面產生數字 i 的 2 進位向量\\ni = 13\\nx = Vector(i%2, (i>>1)%2, (i>>2)%2, (i>>3)%2)\\nx\\n\\n# 請在這裡計算\\n\\n\\n\\n# 參考解答\\n%run -i solutions\\/ff_mod3.py\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n練習\\n設計一個網路:\\n* 輸入是二進位 0 ~ 15\\n* 輸出依照對於 3 的餘數分成三類\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Guided_Evolutionary_Strategies_Demo.ipynb\\\".\\nThe first task is:\\nEvolutionary strategies\\nTo compute descent directions using evolutionary strategies, we will use the antithetic sampler defined above.\\nThis will let us perturb model parameters centered on the current iterate.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef evostrat_update(loss_fn, dists, grads_and_vars, beta, sigma):\\n \\\"\\\"\\\"Function to compute the evolutionary strategies.\\n \\n See the guided ES paper for details on the method.\\n \\n Args:\\n loss_fn: function that builds the graph that computes the loss. loss_fn,\\n when called, returns a scalar loss tensor.\\n dists: dict mapping from variable names to distributions for perturbing\\n those variables.\\n grads_and_vars: list of (gradient, variable) tuples. The gradient and\\n variable are tensors of the same shape. The gradient may be biased (it\\n is not necessarily the gradient of the loss_fn).\\n beta: float, scale hyperparameter of the guided ES algorithm.\\n sigma: float, controls the overall std. dev. of the perturbation\\n distribution.\\n \\n Returns:\\n updates_and_vars: a list of (update, variable) tuples contaniing the\\n estimated descent direction (update) and variable for each variable to\\n optimize. (This list will be passed to a tf.train.Optimizer instance).\\n \\\"\\\"\\\"\\n \\n # build the antithetic sampler\\n anti = AntitheticSampler(dists)\\n \\n # evaluate the loss at different parameters\\n with tf.variable_scope('', custom_getter=anti.pos_getter):\\n y_pos = loss_fn()\\n \\n with tf.variable_scope('', custom_getter=anti.neg_getter):\\n y_neg = loss_fn()\\n \\n # use these losses to compute the evolutionary strategies update\\n c = beta \\/ (2 * sigma ** 2)\\n updates_and_vars = [\\n (c * tf.reshape(anti.perturbations[v.op.name], v.shape) * (y_pos - y_neg), v)\\n for _, v in grads_and_vars]\\n \\n return updates_and_vars\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.19\\/_downloads\\/a47d41a5d6e12802ada8e8ab7ecc9ffc\\/plot_50_configure_mne.ipynb\\\".\\nThe first task is:\\nHowever it is not a good idea to directly edit files in the :file:.mne\\ndirectory; use the getting and setting functions described in the\\nprevious section <config-get-set>.\\nIf for some reason you want to load the configuration from a different\\nlocation, you can pass the home_dir parameter to\\n:func:~mne.get_config_path, specifying the parent directory of the\\n:file:.mne directory where the configuration file you wish to load is\\nstored.\\nUsing environment variables\\n^^^^^^^^^^^^^^^^^^^^^^^^^^^\\nFor compatibility with :doc:MNE-C <..\\/..\\/install\\/mne_c>, MNE-Python\\nalso reads and writes environment variables_ to specify configuration. This\\nis done with the same functions that read and write the JSON configuration,\\nand is controlled with the parameters use_env and set_env. By\\ndefault, :func:~mne.get_config will check :data:os.environ before\\nchecking the MNE-Python JSON file; to check only the JSON file use\\nuse_env=False. To demonstrate, here's an environment variable that is not\\nspecific to MNE-Python (and thus is not in the JSON config file):\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# make sure it's not in the JSON file (no error means our assertion held):\\nassert mne.get_config('PATH', use_env=False) is None\\n# but it *is* in the environment:\\nprint(mne.get_config('PATH'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A continuación represento la evolución temporal del voto por cada partido político, incluyendo las incertidumbres estimadas para cada sondeo.\\n\",\"targets\":\"labelsPartidos = ['PP', 'PSOE', 'PODEMOS+IU', 'Cs', 'Otros']\\nf, ax = pl.subplots(nrows=2, ncols=3, figsize=(10,8))\\nax = ax.flatten()\\nfor i in range(5):\\n ax[i].plot(weekAll, sondeosAll[:,i], '.', color=sns.xkcd_rgb[colors[i]], linewidth=2)\\n ax[i].set_ylim([0,0.35])\\n ax[i].errorbar(weekAll, sondeosAll[:,i], fmt='none', yerr=sigmaAll, color=sns.xkcd_rgb[colors[i]], linewidth=2, ecolor=sns.xkcd_rgb[colors[i]])\\n ax[i].plot(np.arange(max(weekAll))+1, theta[0,:,i], color=sns.xkcd_rgb[colors[i]], linewidth=2)\\n ax[i].fill_between(np.arange(max(weekAll))+1, theta[1,:,i], theta[2,:,i], color=sns.xkcd_rgb[colors[i]], alpha=0.3)\\n ax[i].set_xlabel('Semana')\\n ax[i].set_xlabel('Porcentaje de votos')\\n ax[i].set_title(labelsPartidos[i])\\npl.tight_layout()\\npl.savefig(\\\"porPartido.png\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"14: Convert birth years to integers\\nInstructions\\nLoop over the rows in legislators, and convert the values in the birth year column to integers.\\nIn cases where parsing fails, assign 0 as the value.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfor row in legislators:\\n try:\\n row[7] = int(row[7])\\n except Exception as ex:\\n row[7] = 0\\n\\nprint(legislators)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"02 - Character Building.ipynb\\\".\\nThe first task is:\\nAll that remains to be done is to get them into the usual form that bookworm expects (a list of tuples). We'll call this our list of characters.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ncharacters = [tuple([character + ' ']) for character in set(candidates)]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Notebooks\\/quantopian_research_public\\/notebooks\\/lectures\\/VaR_and_CVaR\\/notebook.ipynb\\\".\\nThe first task is:\\nInterpreting this, we say that historically no more than $5\\\\%$ of days resulted in losses more extreme than this, or that on each day your probability of losing this much is less than $5\\\\%$. Keeping in mind that any forecast like this is just an estimate.\\nNormal vs. Non-Parametric Historical VaR\\nNormal Case\\nA special case of VaR is when you assume that the returns follow a given distribution rather than non-parametrically estiamting it historically. In this case a normal VaR would fit our data, because all our returns were simulated form a normal distribution. We can check this by using a normal distribution Cumulative Distribution Function (CDF), which sums the area under a normal curve to figure out how likely certain values are. We'll use an inverse CDF, or PPF, which for a given likelihood will tell us to which value that likelihood corresponds.\\nSpecifically, the closed form formula for Normal VaR is\\n$$VaR_{\\\\alpha}(x) = \\\\mu - \\\\sigma N^{-1}(\\\\alpha)$$\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Portfolio mean return is unchanged, but std has to be recomputed\\n# This is because independent variances sum, but std is sqrt of variance\\nportfolio_std = np.sqrt( np.power(sigma, 2) * num_assets ) \\/ num_assets\\n\\n# manually \\n(mu - portfolio_std * norm.ppf(0.95)) * value_invested\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"06_reproducibility\\/model_versioning.ipynb\\\".\\nThe first task is:\\nDeploying classification model to AI Platform\\nReplace your-cloud-project below with the name of your cloud project.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Set your cloud project\\nPROJECT = 'your-cloud-project'\\n!gcloud config set project $PROJECT\\n\\nBUCKET = PROJECT + '_flight_model_bucket'\\n\\n# Create a bucket if you don't have one\\n# You only need to run this once\\n!gsutil mb gs:\\/\\/$BUCKET\\n\\n!gsutil cp 'model.bst' gs:\\/\\/$BUCKET\\n\\n# Create the model resource\\n!gcloud ai-platform models create flight_delay_prediction\\n\\n# Create the version\\n!gcloud ai-platform versions create 'v1' \\\\\\n --model 'flight_delay_prediction' \\\\\\n --origin gs:\\/\\/$BUCKET \\\\\\n --runtime-version=1.15 \\\\\\n --framework 'XGBOOST' \\\\\\n --python-version=3.7\\n\\n# Get a prediction on the first example from our test set\\n!rm input.json\\nnum_examples = 10\\nwith open('input.json', 'a') as f:\\n for i in range(num_examples):\\n f.write(str(x_test.iloc[i].values.tolist()))\\n f.write('\\\\n')\\n\\n!cat input.json\\n\\n# Make a prediction to the deployed model\\n!gcloud ai-platform predict --model 'flight_delay_prediction' --version \\\\\\n 'v1' --json-instances 'input.json'\\n\\n# Compare this with actual values\\nprint(y_test.iloc[:5])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"20-10-14-ml-workcamp\\/wc-arbeiten-tf-11-aufgabe.ipynb\\\".\\nThe first task is:\\nWarum stehen da Werte ? Warum sind die Bias Werte 0 ?\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(\\\"Das sind die Parameter in Layer 1: {}\\\".format(inp2.get_weights()))\\n\\nprint(\\\"Das sind die Parameter in Layer 2: {}\\\".format(inp3.get_weights()))\\n\\n# Trainieren Sie das Modell nn2 mit 800 epochs\\nepoch_num = #Wert#\\nhistory = nn3.fit(celsius_i,fahrenheit_o,epochs=epoch_num, verbose=1 )\\nprint(\\\"Das Training ist beendet\\\")\\n\\n# Graphische Darstellung der Ergebnisentwicklung\\nplt.xlabel('Epoch Number')\\nplt.ylabel(\\\"Loss Magnitude\\\")\\nplt.plot(history.history['loss'])\\n\\n# Vorhersage für den Wert 100.0\\nergebnis = nn3.predict([#Wert#])\\nprint(ergebnis)\\n\\n#\\n# Versuchen Sie einmal die Parameter der Layer des Modells nn3 jetzt nach dem Training\\n# auszugeben !\\n#\\ni1 = nn3.layers[0]\\ni2 = nn3.layers[1]\\ni3 = nn3.layers[2]\\n\\nprint(\\\"Das sind die Parameter in Layer 2 nach dem Training: {}\\\".format(i3.get_weights()))\\n\\n#\\n# Wie hat sich der Bias Wert nach dem Training verändert ?\\n#\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# create network only of nodes within 500m walking along the network from point\\nG3 = ox.graph_from_point(location_point, distance=500, distance_type='network', network_type='walk')\\nG3 = ox.project_graph(G3)\\nfig, ax = ox.plot_graph(G3)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNote the plot above shows the network within 500m (traveling distance along the network) from the location_point. By default, the network_type parameter value is 'all', meaning that we do not filter out paths that restrict certain types of traffic. This also means that one-way streets are honored as one-way and you cannot travel the wrong direction down them. Thus, the 500m takes into account only those nodes you can reach within 500m while only traveling in the allowed direction of the street. Instead (below), we can specify network_type='walk' to build a street network only of paths that walking is allowed on. This also makes every path bi-directional in the directed network, because you can walk in either direction on the sidewalk of a one-way street. Thus, the 500m now takes into account those nodes you can reach within 500m while traveling in either direction (even if it's a one-way street).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Basic Cheat Sheet\\nVariable Types in Python\\n\\nNumbers\\nint (integers, limited to 64bit representation), i.e. 10 \\nfloat (floating point real values), i.e 6.2 \\nlong (long integers, limited only to available memory), i.e 10L\\ncomplex (complex numbers), i.e. 0.5j\\nString, i.e. \\\"hello, world!\\\"\\nList, i.e. [1,'star', 3, 'planet', 7]\\nTuple, i.e. (1, 'star', 3, 'planet',7)\\nthink of this as a \\\"read-only\\\" list\\nDictionary, i.e. {'star': 'sun', 'planet': 'earth'}\\nthink of dictionaries as \\\"key-value\\\" pairs\\n\\nArithmetic in Python\\n\\n+ : addition\\n-: subtraction\\n\\/: division\\n*: multiplication\\n%: modulus (remainder)\\n**: exponentiation\\n\\nComparisons and Boolean Operators in Python\\n\\n==, !=: equal to, not equal to\\n<, <=: less than, less than or equal to\\n>, >=: greater than, greater than or equal to\\nor, i.e A or B: true if either A or B or both are true\\nand, i.e. A and B: true only if both are true \\nnot, i.e. not A: true only if A is false\\n\\nBasic Data Types in Python\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Beginning a line with \\\"#\\\" is a comment that is ignored by python\\nmyint = 8 # assigns the integer value to the variable myint\\nprint myint # shows the value assigned to myint on the screen\\nprint type(myint) # shows the variable type of myint, note that we did not have to specify this! python got it.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"An important feature of gradient descent is that there should be a visible improvement over time: In this example, we simply plotted the squared distance from the local minima calculated by gradient descent and the true local minimum, cost, against the iteration during which it was calculated. As we can see, the distance gets smaller over time, but barely changes in later iterations.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nTOOLS = [WheelZoomTool(), ResetTool(), PanTool()]\\n\\n\\nx, y = (zip(*enumerate(cost)))\\ns1 = bp.figure(width=W, \\n height=H, \\n title='Squared distance to true local minimum', \\n# title_text_font_size='14pt', \\n tools=TOOLS,\\n x_axis_label = 'Iteration',\\n y_axis_label = 'Distance'\\n)\\ns1.line(x, y, color=\\\"navy\\\", alpha=0.5, line_width=3)\\ns1.title_text_font_size = '16pt'\\ns1.yaxis.axis_label_text_font_size = \\\"14pt\\\"\\ns1.xaxis.axis_label_text_font_size = \\\"14pt\\\"\\n\\n\\nbp.show(s1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Because $|E_d(e_p)| < |E_s(e_p)|$ we can say that equilibrium is not stable.\\nArc elasticity\\n$$E_{arc} = \\\\frac{Q_n - Q_1}{P_n - P_1} \\\\frac{\\\\frac{\\\\sum_{i=1}^n P_i }{n}}{\\\\frac{\\\\sum_{i=1}^n Q_i }{n}} = \\\\frac{Q_n - Q_1}{P_n - P_1} \\\\frac{\\\\sum_{i=1}^n P_i }{\\\\sum_{i=1}^n Q_i }$$\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef arc_elasticity(P, Q): return (Q[-1] - Q[0]) \\/ (P[-1] - P[0]) * np.sum(P) \\/ np.sum(Q)\\n\\nprint('Demand arc elasticity: {0:.2f}'.format(arc_elasticity(D, P)))\\nprint('Supply arc elasticity: {0:.2f}'.format(arc_elasticity(S, P)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Crossspectrum\\/Crossspectrum_tutorial.ipynb\\\".\\nThe first task is:\\nThe coherence method returns two np.ndarrays, of the coherence and uncertainty.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ncoh, err_coh = avg_cs.coherence()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Because the normal distribution has continuous support, we can generate samples from it forever and we will never see the same sample twice (in theory). We can illustrate this by drawing from the distribution ten thousand times and seeing that we get ten thousand unique values.\\n\",\"targets\":\"from pandas import Series\\n\\nndraws = 10000\\nprint(\\\"Number of unique samples after {} draws:\\\".format(ndraws),)\\ndraws = Series([base_measure() for _ in range(ndraws)])\\nprint(draws.unique().size)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Brainstorm CTF phantom dataset tutorial\\nHere we compute the evoked from raw for the Brainstorm CTF phantom\\ntutorial dataset. For comparison, see :footcite:TadelEtAl2011 and:\\nhttps:\\/\\/neuroimage.usc.edu\\/brainstorm\\/Tutorials\\/PhantomCtf\\n\\nReferences\\n.. footbibliography::\\n\",\"targets\":\"# Authors: Eric Larson \\n#\\n# License: BSD-3-Clause\\n\\nimport os.path as op\\nimport warnings\\n\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\n\\nimport mne\\nfrom mne import fit_dipole\\nfrom mne.datasets.brainstorm import bst_phantom_ctf\\nfrom mne.io import read_raw_ctf\\n\\nprint(__doc__)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Creating New Archive\\n\",\"targets\":\"import tarfile\\nprint('creating archive')\\nwith tarfile.open('tarfile_add.tar', mode='w') as out:\\n print('add zlib_server.py')\\n out.add('zlib_server.py')\\nprint()\\nprint('Contents:')\\nwith tarfile.open('tarfile_add.tar', mode='r') as t:\\n for member_info in t.getmembers():\\n print(member_info.name)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Code\\/Assignment-9\\/GenderDistinguished_ADHD_Bipolar_YatingJing.ipynb\\\".\\nThe first task is:\\nGender 1 ADHD v.s. Bipolar Analysis\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%matplotlib inline\\nimport matplotlib.pyplot as plt\\n\\nplot = df1_all.plot(kind='hist', alpha=0.5, title='Gender 1 Data Distribution', legend=None)\\n\\n# Cluster Gender 1 rCBF features\\nkmeans(df1_all, 'Gender 1')\\n\\n# PCA \\nX1_pca = pca(df1_all, 20)\\n\\n# LLE \\nX1_lle = lle(df1_all, 20) \\n\\n# Classification using PCA features\\nprint 'Using PCA features:'\\nclassify(X1_pca, y1, 'Gender 1', 'PCA')\\n\\n# Classification using LLE features\\nprint 'Using LLE features:'\\nclassify(X1_lle, y1, 'Gender 1', 'LLE')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%sql --module grouped_counts\\n\\nSELECT\\n reference_name,\\n start,\\n end,\\n reference_bases,\\n alternate_bases,\\n vt,\\n SUM(ref_count + alt_count) AS allele_count,\\n SUM(ref_count) AS ref_count,\\n SUM(alt_count) AS alt_count,\\n SUM(IF(TRUE = is_case, INTEGER(ref_count + alt_count), 0)) AS case_count,\\n SUM(IF(FALSE = is_case, INTEGER(ref_count + alt_count), 0)) AS control_count,\\n SUM(IF(TRUE = is_case, ref_count, 0)) AS case_ref_count,\\n SUM(IF(TRUE = is_case, alt_count, 0)) AS case_alt_count,\\n SUM(IF(FALSE = is_case, ref_count, 0)) AS control_ref_count,\\n SUM(IF(FALSE = is_case, alt_count, 0)) AS control_alt_count,\\nFROM $snps\\nGROUP BY\\n reference_name,\\n start,\\n end,\\n reference_bases,\\n alternate_bases,\\n vt\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTallying reference\\/alternate allele counts for case\\/control groups\\nNow that we've assigned each call set to either the case or the control group, we can tally up the counts of reference and alternate alleles within each of our assigned case\\/control groups, for each variant position, like so:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"7: Create a birth year column\\nInstructions\\nLoop through the rows in legislators list, and append the corresponding value in birth_years to each row.\\n\",\"targets\":\"lolists = [[\\\"apple\\\", \\\"monkey\\\"], [\\\"orange\\\", \\\"dog\\\"], [\\\"banana\\\", \\\"cat\\\"]]\\ntrees = [\\\"cedar\\\", \\\"maple\\\", \\\"fig\\\"]\\n\\nfor i, row in enumerate(lolists):\\n row.append(trees[i])\\n\\n# Our list now has a new column containing the values from trees.\\nprint(lolists)\\n\\n# Legislators and birth_years have both been loaded in.\\n\\nfor i, e in enumerate(legislators):\\n e.append(birth_years[i])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# %load exercises\\/4.1-legends_and_scaling.py\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\n\\n# Try to reproduce the figure shown in images\\/exercise_4-1.png\\n# Here's the data and colors used.\\n\\nt = np.linspace(0, 2 * np.pi, 150)\\nx1, y1 = np.cos(t), np.sin(t)\\nx2, y2 = 2 * x1, 2 * y1\\n\\ncolors = ['darkred', 'darkgreen']\\n\\n# Try to plot the two circles, scale the axes as shown and add a legend\\n# Hint: it's easiest to combine `ax.axis(...)` and `ax.margins(...)` to scale\\n# the axes\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise 4.1\\nOnce again, let's use a bit of what we've learned. Try to reproduce the following figure:\\n\\nHint: You'll need to combine ax.axis(...) and ax.margins(...). Here's the data and some code to get you started:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# graficando el sistema de ecuaciones.\\nx_vals = np.linspace(0, 5, 50) # crea 50 valores entre 0 y 5\\nplt.plot(x_vals, (1 - x_vals)\\/-2) # grafica x - 2y = 1\\nplt.plot(x_vals, (11 - (3*x_vals))\\/2) # grafica 3x + 2y = 11\\nplt.axis(ymin = 0)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSistemas de ecuaciones lineales\\nUna de las principales aplicaciones del Álgebra lineal consiste en resolver problemas de sistemas de ecuaciones lineales.\\nUna ecuación lineal es una ecuación que solo involucra sumas y restas de una variable o mas variables a la primera potencia. Es la ecuación de la línea recta.Cuando nuestro problema esta representado por más de una ecuación lineal, hablamos de un sistema de ecuaciones lineales. Por ejemplo, podríamos tener un sistema de dos ecuaciones con dos incógnitas como el siguiente:\\n$$ x - 2y = 1$$ \\n$$3x + 2y = 11$$\\nLa idea es encontrar el valor de $x$ e $y$ que resuelva ambas ecuaciones. Una forma en que podemos hacer esto, puede ser representando graficamente ambas rectas y buscar los puntos en que las rectas se cruzan. \\nEn Python esto se puede hacer en forma muy sencilla con la ayuda de matplotlib.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"And visualise again. Note that both null and alternative distribution are Gaussian, which allows the fast null distribution approximation and the optimal kernel selection\\n\",\"targets\":\"plot_alt_vs_null(alt_samples, null_samples, alpha)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"08-dados_alunos.ipynb\\\".\\nThe first task is:\\nvalores de máximo e minimo da altura significativa e,\\nmédia da altura de onda\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf.describe()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Custom training loop with Keras and MultiWorkerMirroredStrategy\\n\\n \\n View on TensorFlow.org<\\/a>\\n <\\/td>\\n \\n Run in Google Colab<\\/a>\\n <\\/td>\\n \\n View source on GitHub<\\/a>\\n <\\/td>\\n \\n Download notebook<\\/a>\\n <\\/td>\\n<\\/table>\\n\\nOverview\\nThis tutorial demonstrates how to perform multi-worker distributed training with a Keras model and with custom training loops using the tf.distribute.Strategy API. The training loop is distributed via tf.distribute.MultiWorkerMirroredStrategy, such that a tf.keras model—designed to run on single-worker—can seamlessly work on multiple workers with minimal code changes. Custom training loops provide flexibility and a greater control on training, while also making it easier to debug the model. Learn more about writing a basic training loop, writing a training loop from scratch and custom training.\\nIf you are looking for how to use MultiWorkerMirroredStrategy with tf.keras.Model.fit, refer to this tutorial instead.\\nDistributed Training in TensorFlow guide is available for an overview of the distribution strategies TensorFlow supports for those interested in a deeper understanding of tf.distribute.Strategy APIs.\\nSetup\\nFirst, some necessary imports.\\n\",\"targets\":\"import json\\nimport os\\nimport sys\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Cadenas de caracteres (Secuencias)\\nLas cadenas de caracteres en Python son secuencias inmutables, y se pueden aplicar las mismas operaciones comunes a todos los tipos de dato secuencia inmutables, a la vez que no es permitido modificarlos.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npangrama = \\\"El veloz murciélago hindú comía feliz cardillo y kiwi. La cigüeña tocaba el saxofón detrás del palenque de paja\\\"\\nprint(pangrama[3:8])\\n\\npangrama[3:8] = \\\"lento\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.14\\/_downloads\\/plot_introduction.ipynb\\\".\\nThe first task is:\\nRead epochs:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nepochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks,\\n baseline=baseline, preload=False, reject=reject)\\nprint(epochs)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.14\\/_downloads\\/plot_stats_cluster_time_frequency_repeated_measures_anova.ipynb\\\".\\nThe first task is:\\nCreate new stats image with only significant clusters:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ngood_clusers = np.where(cluster_p_values < .05)[0]\\nT_obs_plot = np.ma.masked_array(T_obs,\\n np.invert(clusters[np.squeeze(good_clusers)]))\\n\\nplt.figure()\\nfor f_image, cmap in zip([T_obs, T_obs_plot], [plt.cm.gray, 'RdBu_r']):\\n plt.imshow(f_image, cmap=cmap, extent=[times[0], times[-1],\\n frequencies[0], frequencies[-1]], aspect='auto',\\n origin='lower')\\nplt.xlabel('Time (ms)')\\nplt.ylabel('Frequency (Hz)')\\nplt.title(\\\"Time-locked response for 'modality by location' (%s)\\\\n\\\"\\n \\\" cluster-level corrected (p <= 0.05)\\\" % ch_name)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\nProblem 1\\nThe first problem involves normalizing the features for your training and test data.\\nImplement Min-Max scaling in the normalize_grayscale() function to a range of a=0.1 and b=0.9. After scaling, the values of the pixels in the input data should range from 0.1 to 0.9.\\nSince the raw notMNIST image data is in grayscale, the current values range from a min of 0 to a max of 255.\\nMin-Max Scaling:\\n$\\nX'=a+{\\\\frac {\\\\left(X-X_{\\\\min }\\\\right)\\\\left(b-a\\\\right)}{X_{\\\\max }-X_{\\\\min }}}\\n$\\nIf you're having trouble solving problem 1, you can view the solution here.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Problem 1 - Implement Min-Max scaling for grayscale image data\\ndef normalize_grayscale(image_data):\\n \\\"\\\"\\\"\\n Normalize the image data with Min-Max scaling to a range of [0.1, 0.9]\\n :param image_data: The image data to be normalized\\n :return: Normalized image data\\n \\\"\\\"\\\"\\n # TODO: Implement Min-Max scaling for grayscale image data\\n x = image_data\\n xmin = 0\\n xmax = 255\\n a = 0.1\\n b = 0.9 \\n return a + ( ( (x - xmin)*(b - a) )\\/( xmax - xmin ) )\\n\\n### DON'T MODIFY ANYTHING BELOW ###\\n# Test Cases\\nnp.testing.assert_array_almost_equal(\\n normalize_grayscale(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 255])),\\n [0.1, 0.103137254902, 0.106274509804, 0.109411764706, 0.112549019608, 0.11568627451, 0.118823529412, 0.121960784314,\\n 0.125098039216, 0.128235294118, 0.13137254902, 0.9],\\n decimal=3)\\nnp.testing.assert_array_almost_equal(\\n normalize_grayscale(np.array([0, 1, 10, 20, 30, 40, 233, 244, 254,255])),\\n [0.1, 0.103137254902, 0.13137254902, 0.162745098039, 0.194117647059, 0.225490196078, 0.830980392157, 0.865490196078,\\n 0.896862745098, 0.9])\\n\\nif not is_features_normal:\\n train_features = normalize_grayscale(train_features)\\n test_features = normalize_grayscale(test_features)\\n is_features_normal = True\\n\\nprint('Tests Passed!')\\n\\nif not is_labels_encod:\\n # Turn labels into numbers and apply One-Hot Encoding\\n encoder = LabelBinarizer()\\n encoder.fit(train_labels)\\n train_labels = encoder.transform(train_labels)\\n test_labels = encoder.transform(test_labels)\\n\\n # Change to float32, so it can be multiplied against the features in TensorFlow, which are float32\\n train_labels = train_labels.astype(np.float32)\\n test_labels = test_labels.astype(np.float32)\\n is_labels_encod = True\\n\\nprint('Labels One-Hot Encoded')\\n\\nassert is_features_normal, 'You skipped the step to normalize the features'\\nassert is_labels_encod, 'You skipped the step to One-Hot Encode the labels'\\n\\n# Get randomized datasets for training and validation\\ntrain_features, valid_features,...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"3. <\\/b> Write a function to generate the negative of an image. This means that a new image is created in which the pixel values are all equal to 1.0 minus the pixel value in the original image. \\nPara este punto, primero guardamos la imagen que deseamos utilizar en la variable img. Seguidamente creamos la función neg_im() que no posee parámetros y se encarga de restar 255 a la imagen original. En la variable image, llamamos la función y almacenamos el resultado para luego mostrarlo en una figura con la imagen original para ver el contraste entre las dos.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimg = rg(files[1])\\n\\ndef neg_im():\\n im = 255 - img\\n return im\\n \\nimage = neg_im()\\n \\nmplt.figure()\\nmplt.imshow(img, cmap='gray')\\nmplt.title(files[1])\\n\\nmplt.figure()\\nmplt.imshow(image, cmap='gray')\\nmplt.title(files[1]+'_negative')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Calculer la somme d’une liste des nombres impairs :\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nliste = [2,1,1,2,4,1,3]\\n\\nliste_filtree = [i for i in liste if i % 2 ==1]\\nprint(liste_filtree)\\nsum(liste_filtree)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Run in interactive mode\\nplot_histogram(counts, mode='interactive')\\n\\n# Run in mpl mode\\nplot_histogram(counts, mode='mpl')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nOutput modes for plot_histogram()\\nThere are two output types for the plot_histogram() function, an interactive plot made using an externally hosted JS library for use in Jupyter notebooks, and a locally run plot made using matplotlib. By default the interactive plot will be run if you're running inside a jupyter notebook and only if you have external connectivity to the host with the JS library. But you can use the mode kwarg to select explicitly which mode to use. You can set it to either 'interactive' or 'mpl' to select either interactive or matplotlib respectively. It's also worth noting that if you set it to interactive outside of a jupyter notebook it will fail.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"ANSI also supports a set of 256 indexed colors.\\nThe following code showing all of them is based on http:\\/\\/bitmote.com\\/index.php?post\\/2012\\/11\\/19\\/Using-ANSI-Color-Codes-to-Colorize-Your-Bash-Prompt-on-Linux.\\n\",\"targets\":\"formatstring = '\\\\x1b[38;5;{0};48;5;{0}mX\\\\x1b[1mX\\\\x1b[m'\\n\\nprint(' + ' + ''.join('{:2}'.format(i) for i in range(36)))\\nprint(' 0 ' + ''.join(formatstring.format(i) for i in range(16)))\\nfor i in range(7):\\n i = i * 36 + 16\\n print('{:3} '.format(i) + ''.join(formatstring.format(i + j)\\n for j in range(36) if i + j < 256))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"01_About_Python.ipynb\\\".\\nThe first task is:\\nOther Useful Statistics Libraries:\\n\\nstatsmodel - various statistical routines\\nscikit-learn - machine learning in Python\\npyMC - for bayesian data analysis\\npystan - Bayesian analysis based on stan\\n\\nPython has many libraries for studying graphs, One well-known example is NetworkX\\nHere’s some example code that generates and plots a random graph, with node color determined by shortest path length from a central node\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport networkx as nx\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\n\\nG = nx.random_geometric_graph(200,0.12) # Generate random graph\\npos = nx.get_node_attributes(G, 'pos') # Get positions of nodes\\n# Find node nearest the center point (0.5, 0.5)\\ndists = [(x - 0.5)**2 + (y - 0.5)**2 for x,y in list(pos.values())]\\nncenter = np.argmin(dists)\\n\\n# Plot graph, coloring by path length from central node\\np = nx.single_source_shortest_path_length(G, ncenter)\\nplt.figure()\\nnx.draw_networkx_edges(G, pos, alpha=0.4)\\nnx.draw_networkx_nodes(G, pos, nodelist=list(p.keys()), node_size=120, alpha=0.5,\\n node_color=list(p.values()), cmap=plt.cm.jet_r)\\n\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Content provided under a Creative Commons Attribution license, CC-BY 4.0; code under MIT License. (c)2015 David I. Ketcheson\\nVersion 0.3 - May 2022\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%matplotlib inline\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\nimport matplotlib\\nfrom matplotlib import animation\\nfrom IPython.display import HTML\\nfont = {'size' : 15}\\nmatplotlib.rc('font', **font)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Bar Plots\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%matplotlib inline\\nimport matplotlib.pyplot as plt\\nplt.rcParams[\\\"figure.figsize\\\"] = (15,7)\\n\\n# Declare Values\\nvals = [10, 5, 3, 5, 7,6]\\nxval = [1, 2, 3, 4, 5,6]\\n# Bar Plot\\nplt.bar(xval, vals)\\nplt.title('Sales per Executive')\\nplt.xlabel('ID Number')\\nplt.ylabel('Weekly Sales')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# create a Graphviz file\\nfrom sklearn.tree import export_graphviz\\nexport_graphviz(treereg, out_file='tree_vehicles.dot', feature_names=feature_cols)\\n\\n# At the command line, run this to convert to PNG:\\n# dot -Tpng tree_vehicles.dot -o tree_vehicles.png\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreating a tree diagram\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Final_setup_Random_Forest.ipynb\\\".\\nThe first task is:\\n4.) Maximum depth of tree\\nCan you write Python code for it?\\n\",\"targets\":\"\\nscore=0\\nfor feature in range(1,21):\\n clf = RandomForestClassifier(n_estimators=n_out, criterion=crit_out, max_features=max_feat_out, \\\\\\n max_depth=feature, oob_score=True, random_state=7112016)\\n clf.fit(titanic_features,titanic_target)\\n score_test = clf.oob_score_\\n if score_test>score:\\n depth_out=feature\\n score_diff=score_test-score\\n score=score_test\\n\\nprint depth_out\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Calculen la pseudoinversa X^+ de X y computen (X^+)*sat_score<\\/code> para obtener alpha y beta soluciones.<\\/li>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nXpseudo= pseudoinversa(X)\\nSscore= z.iloc[:,1]\\n\\nab=np.dot(Xpseudo,Sscore)\\nab\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%bash\\ncd \\/tmp\\/Testing\\ngit branch -avv\\n\\n%%bash\\ncd \\/tmp\\/Testing\\ngit checkout master\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAha, now we are set my with both a remote and a local for mybranch1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2. Data\\nlow_memory=False tells Pandas to read more of the file to decide what the types are.\\nparse_dates=[...] is used for any columns that contain dates.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndf_raw = pd.read_csv(f'{PATH}Train.csv', low_memory=False, parse_dates=['saledate'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Are We There Yet?\\nWith code written, how can we tell that it is functioning correctly? One way is the look at the cost over each iteration of the gradient descent algorithm. If this value is decreasing as iterations increase, the values of theta are approaching their optimimum values, as defined by minimizing the cost function. This type of optimization is known as convex optimization, which is an entire field of study to its own. Gradient regression, however, doesn't require much study. \\nWe have all seen gradient descent in action - water always flows downhill! At the top of the hill, the water begins to trickle downward along the slope of the hill, always following the path of steepest descent. To match the analogy, at each point, we calculate the cost and the gradient of the cost, trending down slope along the miniumum gradient. Since we computer users cannot use continuous methods, like mother nature can, we take steps, calculating the cost and cost gradient each time. This step size is set by a parameter called the learning_rate.\\nMore advanced methods of optimization attempt to avoid local minima, using additional parameters like momentum, or different optimization methods which look at different factors, such as gradients-of-gradients. An example of local minima would be a lake on top of a mountain. The lake is the lowest nearby point when compared to the peak, but the bottom of the mountain is much lower than the lake itself. We want to reach the bottom of the mountain, rather than being stuck in the lake. \\nNow that funtime is over, let's look at a plot of cost vs. number of iterations. We can see this plot decrease, asymptotically approaching zero. The differences between stopping at iteration 400 and stopping at iteration 1000 are fairly minimal, and many algorithms use minimal decrease settings to stop iterating when the cost stops decreasing noticeably.\\n\",\"targets\":\"plt.plot(all_cost, color='steelblue')\\nplt.title('Cost over iterations')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"4.2 Add your own measures\\nIt's quite likely that you may want to attribute additional values to each node. For example, in their paper in 2016, Whitaker, Vertes and colleagues correlated the cross sectional decrease in cortical thickness between ages 14 and 24 for each region with its degree. They showed that the hubs - the best connected regions - changed the most in this late adolescent age range.\\nAs we're using this data \\nWe can also add measures as one might normally add nodal attributes to a networkx graph\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndCT = df.loc[:, ['age_scan'] + names].corr().iloc[0, 1:]\\n\\ndCT.head()\\n\\nnx.set_node_attributes(G10, name=\\\"dCT\\\", values={ node: dCT[G10._node[node]['name']] for node in G10.nodes()})\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Class11\\/Class11.ipynb\\\".\\nThe first task is:\\nSo our machine learning algorithm would have to train on 1850 different features! Let's take a look at a couple of the images. We'll first get out the images and their labels. How to do this comes from the documentation for this dataset.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# First we get the list of features\\nimagefeatures = people.data\\n# And the list of labels - this is a set of numbers (0-4) corresponding to the 5 different people\\nimagelabels = people.target\\n# We'd like to get the people's names, too.\\ntarget_names = people.target_names\\nprint(target_names)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"This is quite unreadable and pointless!<\\/h2>\\n\\n We can unstack the groups so that we get borough by agency<\\/h3>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nagency_borough.size().unstack().plot(kind='bar')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Data_analysis\\/SNP-indel-calling\\/dadi\\/dadiExercises\\/example_YRI_CEU.ipynb\\\".\\nThe first task is:\\nThe naming of the function argument for the \\\"number of factors to disturb by\\\" is very unfortunate in this context. Anyway, a higher value leads to greater perturbation.\\nCan you write Python code for it?\\n\",\"targets\":\"\\np0\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#inputs = np.random.random([len(digits.data),64]) # a blank input\\n#for i, item in enumerate(digits.data):\\n# inputs[i] = ((item - digits.data.mean()) \\/ digits.data.std())\\n\\nprint(inputs.shape)\\ninputs\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow, the output numbers seem pretty high, so we might want to normalize the incoming data\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Bayes_test_4params.ipynb\\\".\\nThe first task is:\\nDefine the distribution of measured nucleide concentrations, which is here assumed to be a Gaussian with $\\\\mu$ is predicted by the model above and $\\\\sigma$ the known measurement errors. The likelihood will be derived from this distribution.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nd = pymc.Normal('data_distribution', mprofile, 1.\\/profile_data['std']**2,\\n value=profile_data['C'].values, observed=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Create variables to hold features and outcomes separately\\nfeatures = df.drop('in_sf', axis=1)\\noutcome = df.in_sf\\n\\n# Split data into testing and training sets\\ntrain_features, test_features, train_outcome, test_outcome = train_test_split(features, outcome, test_size=0.30)\\n\\n# Create a classifier and fit your features to your outcome\\nclf = tree.DecisionTreeClassifier()\\nclf = clf.fit(train_features, train_outcome)\\nclf\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nBuild a decision tree using all variables\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!tfx pipeline create --pipeline-path=kubeflow_runner.py --endpoint={ENDPOINT} \\\\\\n--build-image\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLet's create a TFX pipeline using the tfx pipeline create command.\\n\\nNote: When creating a pipeline for KFP, we need a container image which will be used to run our pipeline. And skaffold will build the image for us. Because skaffold pulls base images from the docker hub, it will take 5~10 minutes when we build the image for the first time, but it will take much less time from the second build.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"PwNT Notebook 4.ipynb\\\".\\nThe first task is:\\nWe mentioned earlier that keys() and values() are methods attached to the object nemo, and methods are functions which are attached to Python objects. \\nPython objects often (and often by default!) have methods attached to them. Every dictionary and every list in Python comes with attached methods. Methods can be used to extract properties of objects or change them. Here are examples of some list methods.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nL = [2,3,5,7]\\nprint L # Let's remember what the list L is.\\n\\nprint L[0] # What is this?\\n\\nid(L[0]) # What is the ID number of the 0th item in the list?\\n\\nL.reverse() # The reverse() method changes L!\\nprint L\\n\\nL[0] # We have definitely changed L.\\n\\nL[3] # The last item in the list L.\\n\\nid(L[3]) # The ID number of the last item in the list L.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"PracticalFunctionalProgramming-Python.ipynb\\\".\\nThe first task is:\\n(As you can see, this algorithm can potentially assign the same secret code name to multiple secret agents. Hopefully, this won’t be a source of confusion during the secret mission.)\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport random\\n\\nnames = ['Mary', 'Isla', 'Sam']\\n\\nsecret_names = map(lambda x: random.choice(['Mr. Pink',\\n 'Mr. Orange',\\n 'Mr. Blonde']),\\n names)\\n\\nfor i in secret_names:\\n print(i)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Analyzing taxicab demand\\nLet's pull the number of trips for each day in the 2015 dataset using Standard SQL.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%bq query\\nSELECT \\n EXTRACT (DAYOFYEAR from pickup_datetime) AS daynumber\\nFROM `bigquery-public-data.new_york.tlc_yellow_trips_2015` \\nLIMIT 5\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2020\\/05-geographic-information-system\\/Notebook_Projections.ipynb\\\".\\nThe first task is:\\nComo podemos observar, os valores de coordenadas dos polígonos realmente se parecem com valores de latitude e longitude, então tudo parece estar em ordem.\\n1.2 Calculando a área em metros\\nVamos chamar a função area para o nosso GeoDataFrame e analisar o resultado.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Make a selection that contains only the first five rows\\nselection = data[0:5]\\n\\n# Iterate over rows and print the area of a Polygon\\nfor index, row in selection.iterrows():\\n # Get the area of the polygon\\n poly_area = row['geometry'].area\\n # Get the name att of the polygon\\n poly_name = row['NOME']\\n # Print information for the user\\n print(\\\"Bairro {name} possui uma área de {area:.5f} graus quadrados\\\".format(name=poly_name, \\n area=poly_area))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"8_Calibration\\/8_problem_set.ipynb\\\".\\nThe first task is:\\nImport section specific modules:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom IPython.display import Image\\nfrom scipy import optimize\\n\\nHTML('..\\/style\\/code_toggle.html')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Confusion Matrix\\n\",\"targets\":\"cm = autoModel.leader.confusion_matrix(xval=True)\\ncm = cm.table.as_data_frame()\\ncm\\nconfusionMatrix = ff.create_table(cm)\\nconfusionMatrix.layout.height=300\\nconfusionMatrix.layout.width=800\\nconfusionMatrix.layout.font.size=17\\npy.iplot(confusionMatrix)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"numpy slices are by reference<\\/span>\\n| MATLAB | Numpy |\\n|---|---|\\n|y=x(2,:)|y = x[1,:].copy()|\\n\",\"targets\":\"y=a[1,:]\\nprint(a)\\nprint(y)\\na[1,1]=1\\nprint(y)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"As with lists, individual elements in a tuple can be accessed by indexing.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfoo = (5, 7, 2, 8, 2, -1, 0, 4)\\nfoo[4]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Acho que esse gráfico do G1 tá errado\\nG1 São Paulo\\nNível de água do Cantareira vai a 14,5%; todos reservatórios sobem\\nlink da notícia\\n\\n\",\"targets\":\"from IPython.display import display, Image\\n\\n## eis a imagem da notícia\\ninfograficoG1 = Image('reservatorios1403.jpg')\\ndisplay(infograficoG1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Answer:\\ncompare = pd.DataFrame({'Original': ser, 'Transformed': transformed}, columns=[\\\"Transformed\\\", \\\"Original\\\"])\\ncompare.plot(figsize=(12,9), color=[\\\"blue\\\", \\\"red\\\"])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTask: Visually compare the original and transformed data sets.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# TODO 4a -- your code goes here\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nRun the following command in Cloud Shell:\\ngcloud beta compute ssh --zone <instance-zone> <notebook-instance-name> --project <project-id> -- -L 8081:localhost:8081<\\/code> \\nMake sure to replace <instance-zone>, <notebook-instance-name> and <project-id>.\\nIn Cloud Shell, click Web Preview > Change Port and insert port number 8081. Click Change and Preview to open the TensorBoard.\\n\\nTo quit the TensorBoard, click Kernel > Interrupt kernel.\\nLab Task 4: Embedding lookup and analysis\\nObtain the weights from the model using get_layer() and get_weights(). The get_vocabulary() function provides the vocabulary to build a metadata file with one token per line.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"11\\/homework_11_violations.ipynb\\\".\\nThe first task is:\\nThere sure are a lot of colors of cars, too bad so many of them are the same. Make \\\"BLK\\\" and \\\"BLACK\\\", \\\"WT\\\" and \\\"WHITE\\\", and any other combinations that you notice.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef colorfixer(color):\\n if color in ['BLK', 'BALCK', 'BLACL', 'BK', 'BLCK', 'BLAC']:\\n return 'BLACK'\\n elif color in ['WH', 'WITE', 'WHT', 'WIHTE', 'W', 'WT', 'WHI', 'WYH', 'WHTE']:\\n return 'WHITE'\\n elif color in ['GY', 'GR', 'GRY', 'GREY']:\\n return 'GRAY'\\n elif color in ['GN', 'GRN', 'GREEB']:\\n return 'GREEN'\\n elif color in ['BR', 'SROWN', 'BN', 'BRW', 'BROW', 'BRN', 'BRWN', 'BRO', 'BWN']:\\n return 'BROWN'\\n elif color=='RD':\\n return 'RED'\\n elif color in ['BLU', 'BL', 'BLE', 'B LUE']:\\n return 'BLUE'\\n elif color=='TN':\\n return 'TAN'\\n elif color in ['YELL', 'YEL', 'YELLO', 'YL', 'YW', 'YELLW', 'YLW']:\\n return 'YELLOW'\\n elif color in ['ONG', 'ORAN', 'OR', 'ORANG', 'ORG']:\\n return 'ORANGE'\\n elif color in ['SIL', 'SL', 'SILV', 'SILVE', 'SILVR', 'SIVLE', 'SLVR', 'SLIVE', 'SLV', 'SIV', 'SLR']:\\n return 'SILVER'\\n elif color in ['GL', 'GLD', 'GD']:\\n return 'GOLD'\\n elif color in ['PURPL', 'PUR', 'PURP']:\\n return 'PURPLE'\\n elif color in ['BURGA', 'BURGU', 'BIRG', 'BURG', 'BUR']:\\n return 'BURGUNDY'\\n elif color in ['MAR', 'MARON', 'MAROO', 'MR']:\\n return 'MAROON'\\n elif color in ['BG', 'BIEGE']:\\n return 'BEIGE'\\n else:\\n return color\\n \\n\\nviolations_df['Vehicle Color']=violations_df['Vehicle Color'].apply(lambda row: colorfixer(row))\\n\\nviolations_df['Vehicle Color'].value_counts()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Advanced-SynBio-for-Cell-Factories-Course\\/Predict-growth-coupled-designs-with-OptGene.ipynb\\\".\\nThe first task is:\\nOptGene\\nOptGene is an approach to search for gene or reaction knockouts that relies on evolutionary algorithms[1]. The following image from authors summarizes the OptGene workflow.\\n\\nEvery iteration we keep the best 50 individuals so we can generate a library of targets.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom cameo.strain_design.heuristic.evolutionary_based import OptGene\\n\\noptgene = OptGene(model)\\n\\nresult = optgene.run(target=\\\"EX_ac_e\\\", \\n biomass=model.reactions.BIOMASS_Ecoli_core_w_GAM,\\n substrate=model.metabolites.glc__D_e,\\n max_evaluations=5000,\\n plot=False)\\n\\nresult\\n\\nresult.plot(0)\\n\\nresult.display_on_map(0, \\\"e_coli_core.Core metabolism\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And a text file is really just a list of lines, so:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nlog_file[-10:] # extract last ten lines and show them\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"2 Fonctions\\nLes fonctions sont indispensables en programmation pour créer des entrées-sorties\\n2.1 Déclaration des Fonctions\\nUtilisation du mot clef def\\n\",\"targets\":\"# Here a function that prints something visual\\n# This function has no output variable\\n\\ndef do_twice(f):\\n \\\"\\\"\\\"\\n This function has a docstring\\n It executes twice the function f\\n The program it is used by functions:\\n \\n - do_eight()\\n - print_posts()\\n - print_beams()\\n\\n \\\"\\\"\\\"\\n f()\\n f()\\n\\ndef do_eight(f):\\n \\\"\\\"\\\"\\n Usage:\\n do_eight(function)\\n It executes eight times the passed function\\n \\n Input:\\n The function f is passed as a variable\\n No global variables are passed \\n \\n Local variables\\n No local variables are needed\\n \\n Dependencies\\n The program it is used by functions:\\n \\n -print_grid()\\n\\n\\n \\\"\\\"\\\"\\n do_twice(f)\\n do_twice(f)\\n do_twice(f)\\n do_twice(f)\\n \\n\\ndef print_beam():\\n print('| - - - -',end=\\\" \\\"),\\n\\ndef print_post():\\n print('| ',end=\\\" \\\"),\\n\\ndef print_beams():\\n do_twice(print_beam)\\n print('|',end=\\\"\\\\n\\\")\\n\\ndef print_posts():\\n do_twice(print_post)\\n print('|',end=\\\"\\\\n\\\")\\n\\ndef print_row():\\n print_beams()\\n \\ndef print_grid():\\n print_row()\\n do_eight(print_posts)\\n\\nTitre1='Premier'\\nTitre2='Second'\\nprint('| '+Titre1+' | '+Titre2+' |') \\nprint_grid()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Takes a number and prints if it is even, odd AND >10, or less than 10\\n# Take note of the indentation guys!\\n\\nfor number in [2, 5, 33, 100]:\\n if number % 2 == 0: # number is even\\n print(\\\"{} is even\\\".format(number))\\n if number > 10:\\n print(\\\"{} is odd AND greater than 10\\\".format(number))\\n else:\\n pass # pass is a way to make python do nothing.\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nOnce again, we have two bits of code that will act very differently from one another and the only difference is indentation. In version (A) what happens is we check if 'A' is True and if it is we check if 'B' is True. In the second case, we check if 'B' is True independently of whether 'A' is True.\\nIn short, indentation can be a tricky thing to get right. And this difficulty is compounded by the fact in many cases incorrect code is still syntactically correct. And that means instead of error messages you just get the wrong result.\\nIf, elif, else\\nAs you (hopefully) remember we have already covered if and else in-line; in a previous lecture we were doing stuff like: \\na = True\\nb = 10 if a else 0\\n\\nBut now we have covered indentation we can examine how to use if\\/elif\\/else statements. The Syntax:\\nif {condition}:\\n {code block}\\nelif {condition}:\\n {code block}\\nelse:\\n {code block}\\n\\nWe already understand if\\/else, so the question is \\\"what does 'elif' do?\\\" Well, it stands for 'else if' and it is probably best understood by example:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#Import Numpy and make an example array\\nimport numpy as np \\n#to run a numpy command, use the syntax np.command_name\\nexample_array = np.array([[1,2,3],[4,5,6]]) \\nprint('example_array:\\\\n',example_array)\\nprint('example_array type:',type(example_array))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nImporting packages: numpy\\nnumpy (or Numerical Python) is a useful package for manipulating numbers\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"But if we make the informal sector sufficiently attractive it is possible to get 'urban-bias' or an excessively large urban sector relative to the efficient allocation. \\nFor the following diagram we first make note of the efficient equilibrium wage and rural sector size:\\n\",\"targets\":\"WE, LE = effeq()\\nprint('The efficient competitive wage is w ={:5.2f} and the rural sector is Lr ={:5.0f}'.format(WE, LE))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Adding the input layer and the first hidden layer\\nclassifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu', input_dim = 11))\\n\\n# Adding the second hidden layer\\nclassifier.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu'))\\n\\n# Adding the output layer\\nclassifier.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid'))\\n\\n# Compiling the ANN\\nclassifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])\\n\\n# Fitting the ANN to the Training set\\nclassifier.fit(X_train, y_train, batch_size = 10, epochs = 100)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTips: \\nnumber of nodes in the hidden layer = average of number of nodes in the input layer and number of nodes in the output layer.\\n(11 + 1)\\/2 = 6\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Checking out the results\\nBelow I've plotted some of the test images along with their reconstructions. For the most part these look pretty good except for some blurriness in some parts.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(20,4))\\nin_imgs = mnist.test.images[:10]\\nreconstructed, compressed = sess.run([decoded, encoded], feed_dict={inputs_: in_imgs})\\n\\nfor images, row in zip([in_imgs, reconstructed], axes):\\n for img, ax in zip(images, row):\\n ax.imshow(img.reshape((28, 28)), cmap='Greys_r')\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n\\nfig.tight_layout(pad=0.1)\\n\\nsess.close()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Code\\/notebooks\\/bootcamp_graphics_s17_UG.ipynb\\\".\\nThe first task is:\\nApproach 1: Apply plot methods to dataframes\\nThe simplest way to produce graphics from a dataframe is to apply a plot method to it. \\nWe see that a number of things are preset for us:\\n\\nData. By default the data consists of the whole dataframe. \\nChart type. We have options for lines, bars, or other things, but the default is line\\nx and y variables. By default, the x variable is the dataframe's index and the y variables are the columns of the dataframe -- all of them that can be plotted (e.g. columns with a numeric dtype).\\n\\nWe can change all of these things, but that's always a good starting point.\\nUS GDP and consumption\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# try this with US real GDP, real consumption\\nus.plot()\\n\\n# do GDP alone\\nus['gdp'].plot()\\n\\nus.plot(y=\\\"gdp\\\")\\n\\n# bar chart \\nus.plot(kind='bar')\\n\\n# scatter plot \\n# we need to be explicit about the x and y variables: x = 'gdp', y = 'pce'\\nus.plot.scatter('gdp', 'pce')\\n\\nus.plot('gdp', 'pce', kind='scatter')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# pick a classifier\\n\\nfrom sklearn.tree import DecisionTreeClassifier,DecisionTreeRegressor,ExtraTreeClassifier,ExtraTreeRegressor\\nfrom sklearn.ensemble import RandomForestClassifier,ExtraTreesClassifier\\n\\nclf = RandomForestClassifier()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow we pick a classifier. As you can see, there are many to try \\nout, and even more in scikit-learn's documentation and many \\nexamples and tutorials. Random Forests are data science workhorses. \\nThey are the go-to method for most data scientists. Be careful \\nrelying on them though--they tend to overfit. We try to avoid \\noverfitting by separating the training and test datasets. \\nRandom Forest\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\n\\n\\n \\n <\\/body>\\n<\\/HTML>\\nOpen a notebook\\nRunning jupyter-notebook will launch a server that will open a dashboard view in your browser, usually at the address is at localhost:8888. From the dashboard go to the menu and select new\\/notebook\\/Python to open a new notebook. \\nConnect to ipcluster in your notebook\\nNow from inside a notebook you can connect to the cluster using the ipyparallel library. Below we will connect to the client by providing no additional arguments, which is sufficient in this case sine we are using a very basic ipcluster setup.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport ipyparallel as ipp\\nprint ipp.__version__\\n\\n## connect to ipcluster using default arguments\\nipyclient = ipp.Client()\\n\\n## count how many engines are connected\\nprint len(ipyclient), 'cores'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Lecture-astronomy.ipynb\\\".\\nThe first task is:\\nMaking a table\\nTo make a table manually is easy with Numpy arrays:\\n```python\\nGiven two columns (1D) arr1 and arr2:\\nt1 = Table([arr1, arr2], names=('a', 'b'))\\nThe columns are named “a” and “b”.\\nAdding an additional column:\\ncol1 = Table.Column(name='c', data=arr3)\\nt1.add_column(col1)\\nAdding an additional row:\\nrow = np.array([1, 2, 3])\\nt1.add_row(row)\\n```\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport numpy as np\\nfrom astropy.table import Table\\n%matplotlib inline\\nimport matplotlib.pyplot as plt\\n\\na = np.arange(0,10,0.1)\\nb = a**2\\nt1 = Table([a, b], names=('a', 'b'))\\n\\nplt.plot(t1['a'],t1['b']);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"$$y_i = \\\\beta_0 + \\\\beta_1 x_i + \\\\epsilon_i$$\\n$$\\\\mathbf{\\\\hat{Y}} = \\\\boldsymbol{\\\\beta} \\\\mathbf{X}$$\\n\",\"targets\":\"# OLS is capitalized in the numpy notation\\nmodel2 = sm.OLS(y, X) \\n\\nresults2 = model2.fit()\\n\\nprint(results2.summary())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2.0\\/tutorials\\/plotting.ipynb\\\".\\nThe first task is:\\nLater we'll see how to customize the layout of these subplots in the figure and how to pass other plotting options.\\nSelecting Arrays\\nSo far, each plotting call automatically chose default arrays from that dataset to plot along each axis. To override these defaults, simply point to the qualifier of the array that you'd like plotted along a given axis.\\nCan you write Python code for it?\\n\",\"targets\":\"\\naxs, artists = b['orb01@primary@run_with_incl_80'].plot(x='times', y='vxs')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# заменим пары символов на их смысл\\ndata_1 = \\\"\\\".join(data_letters).replace('Ac', 'P').replace('Ab', '0').replace('Ba', '1')\\nprint(data_1[:300])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nЭто уже почти человеко-читаемо. Сейчас смотрим в даташит и видим, что 'Ac' - импульс и длинная пауза - это преамбула. А 'Ab' и 'Ba' задают 0 и 1.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Compute outer product of vectors\\nv = np.array([1,2,3]) # v has shape (3,)\\nw = np.array([4,5]) # w has shape (2,)\\n# To compute an outer product, we first reshape v to be a column\\n# vector of shape (3, 1); we can then broadcast it against w to yield\\n# an output of shape (3, 2), which is the outer product of v and w:\\n\\nprint np.reshape(v, (3, 1)) * w\\n\\n# Add a vector to each row of a matrix\\nx = np.array([[1,2,3], [4,5,6]])\\n# x has shape (2, 3) and v has shape (3,) so they broadcast to (2, 3),\\n# giving the following matrix:\\n\\nprint x + v\\n\\n# Add a vector to each column of a matrix\\n# x has shape (2, 3) and w has shape (2,).\\n# If we transpose x then it has shape (3, 2) and can be broadcast\\n# against w to yield a result of shape (3, 2); transposing this result\\n# yields the final result of shape (2, 3) which is the matrix x with\\n# the vector w added to each column. Gives the following matrix:\\n\\nprint (x.T + w).T\\n\\n# Another solution is to reshape w to be a row vector of shape (2, 1);\\n# we can then broadcast it directly against x to produce the same\\n# output.\\nprint x + np.reshape(w, (2, 1))\\n\\n# Multiply a matrix by a constant:\\n# x has shape (2, 3). Numpy treats scalars as arrays of shape ();\\n# these can be broadcast together to shape (2, 3), producing the\\n# following array:\\nprint x * 2\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe line y = x + v works even though x has shape (4, 3) and v has shape (3,) due to broadcasting; this line works as if v actually had shape (4, 3), where each row was a copy of v, and the sum was performed elementwise.\\nBroadcasting two arrays together follows these rules:\\n\\nIf the arrays do not have the same rank, prepend the shape of the lower rank array with 1s until both shapes have the same length.\\nThe two arrays are said to be compatible in a dimension if they have the same size in the dimension, or if one of the arrays has size 1 in that dimension.\\nThe arrays can be broadcast together if they are compatible in all dimensions.\\nAfter broadcasting, each array behaves as if it had shape equal to the elementwise maximum of shapes of the two input arrays.\\nIn any dimension where one array had size 1 and the other array had size greater than 1, the first array behaves as if it were copied along that dimension\\n\\nIf this explanation does not make sense, try reading the explanation from the documentation or this explanation.\\nFunctions that support broadcasting are known as universal functions. You can find the list of all universal functions in the documentation.\\nHere are some applications of broadcasting:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"02_numpy_indexing.ipynb\\\".\\nThe first task is:\\nMatrix algebra\\nWhat about matrix mutiplication? \\nThere are two ways. \\nWe can either use the np.dot function, which applies a matrix-matrix, matrix-vector, or inner vector multiplication to its two arguments:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnp.dot(A, A)\\n\\nnp.dot(A, v1)\\n\\nnp.dot(v1, v1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%matplotlib inline\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWhen you use the IPython notebook, you can print plots to the output of individual cells by including the magic command:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Name our classical registers:\\ntest_register = 1\\nanswer_register = 0\\n\\n# Construct each branch of our if-statement. We can have empty branches\\n# simply by having empty programs.\\nthen_branch = pq.Program(X(0))\\nelse_branch = pq.Program()\\n\\n# Make a program that will put a 0 or 1 in test_register with 50% probability:\\nbranching_prog = pq.Program(H(1)).measure(1, test_register)\\n\\n# Add the conditional branching:\\nbranching_prog.if_then(test_register, then_branch, else_branch)\\n\\n# Measure qubit 0 into our answer register:\\nbranching_prog.measure(0, answer_register)\\n\\nprint branching_prog\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNotice that the init_register program applied a Quil instruction directly to a classical register. There are several classical commands that can be used in this fashion:\\n\\nTRUE which sets a single classical bit to be 1\\nFALSE which sets a single classical bit to be 0\\nNOT which flips a classical bit\\nAND which operates on two classical bits\\nOR which operates on two classical bits\\nMOVE which moves the value of a classical bit at one classical address into another\\nEXCHANGE which swaps the value of two classical bits\\n\\nIn this next example, we show how to do conditional branching in the form of the traditional if construct as in many programming languages. Much like the last example, we construct programs for each branch of the if, and put it all together by using the if_then method.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%brython -c table\\nfrom browser import document, html\\n\\ntable = html.TABLE()\\n\\nfor i in range(10):\\n color = ['cyan','#dddddd'] * 5\\n table <= html.TR(\\n html.TD(str(i+1) + ' x 2 =', style = {'backgroundColor':color[i]}) + \\n html.TD((i+1)*2, style = {'backgroundColor':color[i]}))\\ndocument['table'] <= table\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nA more useful example: A multiplication table\\nIn the following cell we create a multiplication table. First, we create a table tag. We append the table rows and cells (TR and TD tags) and, finally, we append the final table to the div with \\\"table\\\" id attribute.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Modify these variables according to your needs.\\napplication_name = \\\"Distributed Keras MNIST Analysis\\\"\\nusing_spark_2 = False\\nlocal = False\\npath = \\\"mnist.parquet\\\"\\nif local:\\n # Tell master to use local resources.\\n master = \\\"local[*]\\\"\\n num_processes = 3\\n num_executors = 1\\nelse:\\n # Tell master to use YARN.\\n master = \\\"yarn-client\\\"\\n num_executors = 30\\n num_processes = 1\\n\\n# This variable is derived from the number of cores and executors, and will be used to assign the number of model trainers.\\nnum_workers = num_executors * num_processes\\n\\nprint(\\\"Number of desired executors: \\\" + `num_executors`)\\nprint(\\\"Number of desired processes \\/ executor: \\\" + `num_processes`)\\nprint(\\\"Total number of workers: \\\" + `num_workers`)\\n\\nconf = SparkConf()\\nconf.set(\\\"spark.app.name\\\", application_name)\\nconf.set(\\\"spark.master\\\", master)\\nconf.set(\\\"spark.executor.cores\\\", `num_processes`)\\nconf.set(\\\"spark.executor.instances\\\", `num_executors`)\\nconf.set(\\\"spark.locality.wait\\\", \\\"0\\\")\\nconf.set(\\\"spark.executor.memory\\\", \\\"5g\\\")\\nconf.set(\\\"spark.serializer\\\", \\\"org.apache.spark.serializer.KryoSerializer\\\");\\n\\n# Check if the user is running Spark 2.0 +\\nif using_spark_2:\\n sc = SparkSession.builder.config(conf=conf) \\\\\\n .appName(application_name) \\\\\\n .getOrCreate()\\nelse:\\n # Create the Spark context.\\n sc = SparkContext(conf=conf)\\n # Add the missing imports\\n from pyspark import SQLContext\\n sqlContext = SQLContext(sc)\\n\\n# Check if we are using Spark 2.0\\nif using_spark_2:\\n reader = sc\\nelse:\\n reader = sqlContext\\n# Read the training and test set.\\ntraining_set = reader.read.parquet('data\\/mnist_train_big.parquet') \\\\\\n .select(\\\"features_normalized_dense\\\", \\\"label_encoded\\\", \\\"label\\\")\\ntest_set = reader.read.parquet('data\\/mnist_test_preprocessed.parquet') \\\\\\n .select(\\\"features_normalized_dense\\\", \\\"label_encoded\\\", \\\"label\\\")\\n\\n# Print the schema of the dataset.\\ntraining_set.printSchema()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIn the following cell, adapt the parameters to fit your personal requirements.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Blobs 2\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Create blobs\\n# The coordinates of the centers of our blobs.\\ncenters = [[0, 0], [-10, 0], [10, 0]]\\n\\n# Make 10,000 rows worth of data with two features representing three\\n# clusters, each having a standard deviation of 1.\\nX, y = make_blobs(\\n n_samples=10000,\\n centers=centers,\\n cluster_std=1.5,\\n n_features=2,\\n random_state=123)\\n\\nplt.scatter(X[:, 0], X[:, 1], c=y)\\nplt.show()\\n\\n#Divide into training and test sets.\\nX_train, X_test, y_train, y_test = train_test_split(\\n X,\\n y,\\n test_size=0.9,\\n random_state=42)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Intro_to_Neural_Networks\\/Planar+data+classification+with+one+hidden+layer+v4.ipynb\\\".\\nThe first task is:\\nExpected Output:\\n\\n\\n \\n \\n \\n \\n \\n \\n \\n **cost after iteration 0**\\n <\\/td>\\n \\n 0.692739\\n <\\/td>\\n<\\/tr>\\n\\n \\n $\\\\vdots$ <\\/center>\\n <\\/td>\\n \\n $\\\\vdots$ <\\/center>\\n <\\/td>\\n<\\/tr>\\n\\n **W1**<\\/td>\\n [[-0.65848169 1.21866811]\\n [-0.76204273 1.39377573]\\n [ 0.5792005 -1.10397703]\\n [ 0.76773391 -1.41477129]]<\\/td> \\n <\\/tr>\\n\\n **b1**<\\/td>\\n [[ 0.287592 ]\\n [ 0.3511264 ]\\n [-0.2431246 ]\\n [-0.35772805]] <\\/td> \\n <\\/tr>\\n\\n **W2**<\\/td>\\n [[-2.45566237 -3.27042274 2.00784958 3.36773273]] <\\/td> \\n <\\/tr>\\n\\n\\n **b2**<\\/td>\\n [[ 0.20459656]] <\\/td> \\n <\\/tr>\\n\\n<\\/table>\\n\\n4.5 Predictions\\nQuestion: Use your model to predict by building predict().\\nUse forward propagation to predict results.\\nReminder: predictions = $y_{prediction} = \\\\mathbb 1 \\\\text{{activation > 0.5}} = \\\\begin{cases}\\n 1 & \\\\text{if}\\\\ activation > 0.5 \\\\\\n 0 & \\\\text{otherwise}\\n \\\\end{cases}$ \\nAs an example, if you would like to set the entries of a matrix X to 0 and 1 based on a threshold you would do: X_new = (X > threshold)\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# GRADED FUNCTION: predict\\n\\ndef predict(parameters, X):\\n \\\"\\\"\\\"\\n Using the learned parameters, predicts a class for each example in X\\n \\n Arguments:\\n parameters -- python dictionary containing your parameters \\n X -- input data of size (n_x, m)\\n \\n Returns\\n predictions -- vector of predictions of our model (red: 0 \\/ blue: 1)\\n \\\"\\\"\\\"\\n \\n # Computes probabilities using forward propagation, and classifies to 0\\/1 using 0.5 as the threshold.\\n ### START CODE HERE ### (≈ 2 lines of code)\\n A2, cache = forward_propagation(X, parameters)\\n predictions = np.round(A2)\\n ### END CODE HERE ###\\n \\n return predictions\\n\\nparameters, X_assess = predict_test_case()\\n\\npredictions = predict(parameters, X_assess)\\nprint(\\\"predictions mean = \\\" + str(np.mean(predictions)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# create a 2D array of random numbers\\ndata_slice = np.random.uniform(low=280,high=330,size=(nlats,nlons))\\ntemp[3,:,:] = data_slice # Appends the 4th time slice\\nprint(\\\"-- Wrote more data, temp.shape is now \\\", temp.shape)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nYou can just treat a netCDF Variable object like a numpy array and assign values to it.\\nVariables automatically grow along unlimited dimensions (unlike numpy arrays)\\nThe above writes the whole 3D variable all at once, but you can write it a slice at a time instead.\\n\\nLet's add another time slice....\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Character-level LSTM\\nNow that we know the basics of RNNs, let's build a character-level LSTM language-model.\\nWe have a sequence LSTM that, at each step, gets as input a character, and needs to predict the next character.\\n\",\"targets\":\"import random\\nfrom collections import defaultdict\\nfrom itertools import count\\nimport sys\\n\\nLAYERS = 1\\nINPUT_DIM = 50 \\nHIDDEN_DIM = 50 \\n\\ncharacters = list(\\\"abcdefghijklmnopqrstuvwxyz \\\")\\ncharacters.append(\\\"\\\")\\n\\nint2char = list(characters)\\nchar2int = {c:i for i,c in enumerate(characters)}\\n\\nVOCAB_SIZE = len(characters)\\n\\n\\n\\npc = dy.ParameterCollection()\\n\\n\\nsrnn = dy.SimpleRNNBuilder(LAYERS, INPUT_DIM, HIDDEN_DIM, pc)\\nlstm = dy.LSTMBuilder(LAYERS, INPUT_DIM, HIDDEN_DIM, pc)\\n\\n# add parameters for the hidden->output part for both lstm and srnn\\nparams_lstm = {}\\nparams_srnn = {}\\nfor params in [params_lstm, params_srnn]:\\n params[\\\"lookup\\\"] = pc.add_lookup_parameters((VOCAB_SIZE, INPUT_DIM))\\n params[\\\"R\\\"] = pc.add_parameters((VOCAB_SIZE, HIDDEN_DIM))\\n params[\\\"bias\\\"] = pc.add_parameters((VOCAB_SIZE))\\n\\n# return compute loss of RNN for one sentence\\ndef do_one_sentence(rnn, params, sentence):\\n # setup the sentence\\n dy.renew_cg()\\n s0 = rnn.initial_state()\\n \\n \\n R = params[\\\"R\\\"]\\n bias = params[\\\"bias\\\"]\\n lookup = params[\\\"lookup\\\"]\\n sentence = [\\\"\\\"] + list(sentence) + [\\\"\\\"]\\n sentence = [char2int[c] for c in sentence]\\n s = s0\\n loss = []\\n for char,next_char in zip(sentence,sentence[1:]):\\n s = s.add_input(lookup[char])\\n probs = dy.softmax(R*s.output() + bias)\\n loss.append( -dy.log(dy.pick(probs,next_char)) )\\n loss = dy.esum(loss)\\n return loss\\n \\n\\n# generate from model:\\ndef generate(rnn, params):\\n def sample(probs):\\n rnd = random.random()\\n for i,p in enumerate(probs):\\n rnd -= p\\n if rnd <= 0: break\\n return i\\n \\n # setup the sentence\\n dy.renew_cg()\\n s0 = rnn.initial_state()\\n \\n R = params[\\\"R\\\"]\\n bias = params[\\\"bias\\\"]\\n lookup = params[\\\"lookup\\\"]\\n \\n s = s0.add_input(lookup[char2int[\\\"\\\"]])\\n out=[]\\n while True:\\n probs = dy.softmax(R*s.output() + bias)\\n probs = probs.vec_value()\\n next_char = sample(probs)\\n out.append(int2char[next_char])\\n if...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Predict housing price for the sample_house\\nprediction = model.predict(sample_house)\\nprint(prediction)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPrediction\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%cython -a\\n\\nimport numpy as np\\ncimport numpy as np\\n\\ndef angdistcut_cython_typed(double[:,::1] vec_obj, double[:,::1] vec_ps, double cos_maxsep):\\n \\\"\\\"\\\"\\n NB: double[:] --> \\\"typed memoryview\\\": gives fast access to numpy-like arrays in Cython\\n double[:,::1] --> 2D typed memoryview, with last index varying fastest\\n for this it needs to be C contigous\\n \\\"\\\"\\\"\\n \\n cdef:\\n int nps = vec_ps.shape[0]\\n int nobj = vec_obj.shape[0]\\n int dim = vec_obj.shape[1]\\n #use int array instead of list\\n int[:] found = np.zeros(nobj, np.int32)\\n int i,j\\n double cos\\n\\n for i in range(nobj):\\n for j in range(nps):\\n cos = (vec_obj[i,0]*vec_ps[j,0] + \\n vec_obj[i,1]*vec_ps[j,1] + \\n vec_obj[i,2]*vec_ps[j,2])\\n if cos > cos_maxsep:\\n found[i] = 1\\n break\\n #convert result from typed memory view into array before returning \\n return np.flatnonzero(np.asarray(found))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nEssentially all Python code is valid Cython code. But without adding type definitions we get only a very small speed-up.\\nAdding static type definitions\\nHere we make use of Cython's typed memorview. This is a container that provides fast access to numpy-like arrays in Cython.\\nNB: I have also made one small change to the algorithm: instead of appending to a list I use an array to store which objects are flagged as contaminated, and at the end return the nonzero elements of that array (similar to the numpy case above.)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Analyse général des données\\n\",\"targets\":\"sns.factorplot('is_Family', data=data,hue='Sex', kind='count')\\n\\nsns.factorplot('Pclass', data=data,hue='Sex', kind='count')\\n\\nfig = sns.FacetGrid(data, row=\\\"Sex\\\", col='Pclass')\\nfig.map(sns.barplot,'is_Family', 'Survived')\\n\\nfig = sns.FacetGrid(data, row=\\\"Sex\\\", col='Pclass')\\nfig.map(sns.kdeplot,'Age')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"11b. Now run the code, Did the contents of list1 change?\\n11c. If you called the change_first function on array1, would the contents of array1 change?\\n11d. Explain the behavior that you see when you run the change_first function on a list or array.\\nModel 2: Assignments\\nWe also need to be understand when we assign a new variable to an existing collection of data, whether we are referring to the original collection or a copy of the entire collection:\\n\\nFor each of the code cells below, predict the output BEFORE running them (\\\"prediction\\\"), then run and comment on whether the original variable changed or not (\\\"analysis\\\").\\n12a. Prediction:\\n\",\"targets\":\"## Q12 code\\nx = 0\\ny = x\\ny = 50\\nprint(x)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Always use cls for the first argument to class methods\\nOK<\\/font>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nclass MyClass(object):\\n def __init__(self):\\n pass\\n def my_method1(self):\\n pass\\n @classmethod\\n def my_class_method_foo(cls):\\n pass\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Also, if you think the Python boilerplate code to call a GPU kernel was a bit messy, we've got good news for you! From now on, we'll only use the Kernel Tuner to compile and benchmark GPU kernels, which we can do with much cleaner Python code.\\nAuto-Tuning with the Kernel Tuner\\nRemember that previously we've set the thread block dimensions to 16 by 16. But how do we actually know if that is the best performing setting? That is where auto-tuning comes into play. Basically, it is very difficult to provide an answer through performance modeling and as such, we'd rather use the Kernel Tuner to compile and benchmark all possible kernel configurations.\\nBut before we continue, we'll increase the problem size, because the GPU is very likely underutilized.\\n\",\"targets\":\"nx = 4096\\nny = 4096\\nfield = get_initial_conditions(nx, ny)\\nkernel_string = get_kernel_string(nx, ny)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Parameter Configuration\\n\\nparam_r = {\\\"parameter_id\\\": \\\"r\\\", \\\"double_value_spec\\\": {\\\"min_value\\\": 0, \\\"max_value\\\": 1}}\\n\\nparam_theta = {\\n \\\"parameter_id\\\": \\\"theta\\\",\\n \\\"double_value_spec\\\": {\\\"min_value\\\": 0, \\\"max_value\\\": 1.57},\\n}\\n\\n# Objective Metrics\\nmetric_y1 = # TODO -- Your code goes here\\n\\n# Objective Metrics\\nmetric_y2 = # TODO -- Your code goes here\\n\\n# Put it all together in a study configuration\\nstudy = {\\n \\\"display_name\\\": STUDY_DISPLAY_NAME,\\n \\\"study_spec\\\": {\\n \\\"algorithm\\\": \\\"RANDOM_SEARCH\\\",\\n \\\"parameters\\\": [\\n param_r,\\n param_theta,\\n ],\\n \\\"metrics\\\": [metric_y1, metric_y2],\\n },\\n}\\n\\nprint(json.dumps(study, indent=2, sort_keys=True))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreate the study configuration\\nThe following is a sample study configuration, built as a hierarchical python dictionary. It is already filled out. Run the cell to configure the study.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"And now we have the main training loop.\\n\",\"targets\":\"@eqx.filter_jit\\ndef make_step(model, weight, int_beta, data, t1, key, opt_state, opt_update):\\n loss_fn = eqx.filter_value_and_grad(batch_loss_fn)\\n loss, grads = loss_fn(model, weight, int_beta, data, t1, key)\\n updates, opt_state = opt_update(grads, opt_state)\\n model = eqx.apply_updates(model, updates)\\n key = jr.split(key, 1)[0]\\n return loss, model, key, opt_state\\n\\n\\ndef main(\\n # Model hyperparameters\\n patch_size=4,\\n hidden_size=64,\\n mix_patch_size=512,\\n mix_hidden_size=512,\\n num_blocks=4,\\n t1=10.0,\\n # Optimisation hyperparameters\\n num_steps=1_000_000,\\n lr=3e-4,\\n batch_size=256,\\n print_every=10_000,\\n # Sampling hyperparameters\\n dt0=0.1,\\n sample_size=10,\\n # Seed\\n seed=5678,\\n):\\n key = jr.PRNGKey(seed)\\n model_key, train_key, loader_key, sample_key = jr.split(key, 4)\\n data = mnist()\\n data_mean = jnp.mean(data)\\n data_std = jnp.std(data)\\n data_max = jnp.max(data)\\n data_min = jnp.min(data)\\n data_shape = data.shape[1:]\\n data = (data - data_mean) \\/ data_std\\n\\n model = Mixer2d(\\n data_shape,\\n patch_size,\\n hidden_size,\\n mix_patch_size,\\n mix_hidden_size,\\n num_blocks,\\n t1,\\n key=model_key,\\n )\\n int_beta = lambda t: t # Try experimenting with other options here!\\n weight = lambda t: 1 - jnp.exp(\\n -int_beta(t)\\n ) # Just chosen to upweight the region near t=0.\\n\\n opt = optax.adabelief(lr)\\n # Optax will update the floating-point JAX arrays in the model.\\n opt_state = opt.init(eqx.filter(model, eqx.is_inexact_array))\\n\\n total_value = 0\\n total_size = 0\\n for step, data in zip(\\n range(num_steps), dataloader(data, batch_size, key=loader_key)\\n ):\\n value, model, train_key, opt_state = make_step(\\n model, weight, int_beta, data, t1, train_key, opt_state, opt.update\\n )\\n total_value += value.item()\\n total_size += 1\\n if (step % print_every) == 0 or step == num_steps - 1:\\n print(f\\\"Step={step}...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Euler.ipynb\\\".\\nThe first task is:\\n9. Special Pythagorean triplet\\nA Pythagorean triplet is a set of three natural numbers, a < b < c, for which,\\na2 + b2 = c2\\nFor example, 32 + 42 = 9 + 16 = 25 = 52.\\nThere exists exactly one Pythagorean triplet for which a + b + c = 1000.\\nFind the product abc.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nsquares_list = filter(lambda x: x** 0.5 == int(x**0.5), range(1,1000000))\\n\\n\\nsquares_list[:10]\\nsquares_set = set(squares_list)\\ntriplets = []\\nfor index,square in enumerate(squares_list):\\n for another_square in squares_list[index+1:]:\\n if another_square + square in squares_set:\\n triplets.append((square, another_square, square+another_square))\\n\\nfor number in filter(lambda x: x[0]**(.5) + x[1]**(.5) + x[2]**(.5) == 1000, triplets)[0] :\\n print number**(.5)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"L2 - BUC.ipynb\\\".\\nThe first task is:\\nWith the following pivot table, we can easily see the output is correct (i.e., all the (non-empty) aggregates are computed). \\nBut did you notice anything else interesting?\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndata.pivot_table(index = ['A'], columns = ['B'], aggfunc = np.sum, margins = True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Load the sociopatterns network data.\\n#G = cf.load_sociopatterns_network()\\nG=nx.read_gpickle('Synthetic Social Network.pkl')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLoad Data\\nWe will load the sociopatterns network data for this notebook. From the Konect website:\\n\\nThis network describes the face-to-face behavior of people during the exhibition INFECTIOUS: STAY AWAY in 2009 at the Science Gallery in Dublin. Nodes represent exhibition visitors; edges represent face-to-face contacts that were active for at least 20 seconds. Multiple edges between two nodes are possible and denote multiple contacts. The network contains the data from the day with the most interactions.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# %load _solutions\\/case1_bike_count25.py\\n\\n# %load _solutions\\/case1_bike_count26.py\\n\\n# %load _solutions\\/case1_bike_count27.py\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNew Year's Eve 2013-2014\\n\\n\\n**EXERCISE 13**\\n\\n- Select a subset of the dataset from 2013-12-31 12:00:00 until 2014-01-01 12:00:00 and assign the result to a new variable `newyear`\\n- Plot the selected data `newyear`.\\n- Use a `rolling` function with a window of 10 values (check documentation of the function) to smooth the data of this period and make a plot of the smoothed version.\\n\\nHints<\\/summary>\\n\\n- Just like `resample`, `rolling` requires an aggregate statistic (e.g. mean, median,...) to combine the values within the window.\\n\\n<\\/details>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Creating DataFrames\\n\\nDataFrame can also be created manually, by grouping several Series together.\\n\\nNow just for fun we switch to another dataset\\n\\ncreate 2 Series objects from 2 CSV files\\ncreate a DataFrame by combining the two Series\\n\\n\\n\\nData are monthly values of\\n\\nSouthern Oscillation Index (SOI)\\nOutgoing Longwave Radiation (OLR), which is a proxy for convective precipitation in the western equatorial Pacific\\n\\n\\nData were downloaded from NOAA's website: https:\\/\\/www.ncdc.noaa.gov\\/teleconnections\\/\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsoi_df = pd.read_csv('..\\/data\\/soi.csv', skiprows=1, parse_dates=[0], index_col=0, na_values=-999.9,\\n date_parser=lambda x: pd.datetime.strptime(x, '%Y%m'))\\n\\nolr_df = pd.read_csv('..\\/data\\/olr.csv', skiprows=1, parse_dates=[0], index_col=0, na_values=-999.9,\\n date_parser=lambda x: pd.datetime.strptime(x, '%Y%m'))\\n\\ndf = pd.DataFrame({'OLR': olr_df.Value,\\n 'SOI': soi_df.Value})\\n\\n# df.describe()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Probability-Theory\\/Chapter_02.ipynb\\\".\\nThe first task is:\\n2.2 exponential distribution\\n$$f(x)=\\n\\\\begin{cases}\\n\\\\lambda e^{-\\\\lambda x}, x >0 \\\\\\n0, x \\\\le 0\\n\\\\end{cases}$$\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\nlam = 5\\nx = np.linspace(0.01, 1, 1000)\\nf_x = lam * np.power(np.e, -1.0*lam*x)\\nplt.plot(x, f_x)\\nplt.xlabel('x')\\nplt.ylabel(r'$f(x)$')\\nplt.axis([0, 1.1, 0, 2])\\nplt.xticks(())\\nplt.yticks(())\\ngca = plt.gca()\\ngca.spines['right'].set_color('none')\\ngca.spines['top'].set_color('none')\\ngca.xaxis.set_ticks_position('bottom')\\ngca.yaxis.set_ticks_position('left')\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Data Exploration\\nIn this first section of this project, you will make a cursory investigation about the Boston housing data and provide your observations. Familiarizing yourself with the data through an explorative process is a fundamental practice to help you better understand and justify your results.\\nSince the main goal of this project is to construct a working model which has the capability of predicting the value of houses, we will need to separate the dataset into features and the target variable. The features, 'RM', 'LSTAT', and 'PTRATIO', give us quantitative information about each data point. The target variable, 'MEDV', will be the variable we seek to predict. These are stored in features and prices, respectively.\\nImplementation: Calculate Statistics\\nFor your very first coding implementation, you will calculate descriptive statistics about the Boston housing prices. Since numpy has already been imported for you, use this library to perform the necessary calculations. These statistics will be extremely important later on to analyze various prediction results from the constructed model.\\nIn the code cell below, you will need to implement the following:\\n- Calculate the minimum, maximum, mean, median, and standard deviation of 'MEDV', which is stored in prices.\\n - Store each calculation in their respective variable.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnp.median(prices)\\n\\n# TODO: Minimum price of the data\\nminimum_price = np.min(prices)\\n\\n# TODO: Maximum price of the data\\nmaximum_price = np.max(prices)\\n\\n# TODO: Mean price of the data\\nmean_price = np.mean(prices)\\n\\n# TODO: Median price of the data\\nmedian_price = np.median(prices)\\n\\n# TODO: Standard deviation of prices of the data\\nstd_price = np.std(prices)\\n\\n# Show the calculated statistics\\nprint \\\"Statistics for Boston housing dataset:\\\\n\\\"\\nprint \\\"Minimum price: ${:,.2f}\\\".format(minimum_price)\\nprint \\\"Maximum price: ${:,.2f}\\\".format(maximum_price)\\nprint \\\"Mean price: ${:,.2f}\\\".format(mean_price)\\nprint \\\"Median price ${:,.2f}\\\".format(median_price)\\nprint \\\"Standard deviation of prices: ${:,.2f}\\\".format(std_price)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Bucketized columns\\nOften, you don't want to feed a number directly into the model, but instead split its value into different categories based on numerical ranges. Consider raw data that represents a person's age. Instead of representing age as a numeric column, we could split the age into several buckets using a bucketized column. Notice the one-hot values below describe which age range each row matches.\\n\",\"targets\":\"age_buckets = tf.feature_column.bucketized_column(age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])\\ndemo(____) # TODO 3a: Replace the blanks with a correct value\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Date range for data we are interested\\nstart = datetime(2016, 12, 1)\\nend = datetime(2017, 3, 1)\\n\\n# MesoWest station ID.\\nstn = 'MTMET'\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nOk, lets get some data\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Classification might be the most well-known application of Bayesian methods, made famous in the 1990s as the basis of the first generation of spam filters.\\nIn this chapter, I'll demonstrate Bayesian classification using data collected and made available by Dr. Kristen Gorman at the Palmer Long-Term Ecological Research Station in Antarctica (see Gorman, Williams, and Fraser, \\\"Ecological Sexual Dimorphism and Environmental Variability within a Community of Antarctic Penguins (Genus Pygoscelis)\\\", March 2014).\\nWe'll use this data to classify penguins by species.\\nThe following cell downloads the raw data.\\n\",\"targets\":\"# Load the data files from \\n# https:\\/\\/github.com\\/allisonhorst\\/palmerpenguins\\n# With gratitude to Allison Horst (@allison_horst)\\n\\ndownload('https:\\/\\/github.com\\/allisonhorst\\/palmerpenguins\\/raw\\/master\\/inst\\/extdata\\/penguins_raw.csv')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# find cohort of users who first used app on Feb 4th, Feb 10th, and Feb 14th\\ncohort = {}\\ndef range_date(start, end):\\n delta = end - start\\n for n in range(delta.days + 1):\\n yield start + timedelta(n)\\n\\n# calculate daily retention rate for each cohort\\ndef retention_rate(start_date):\\n end_date = date(2016,2,29)\\n # the cohort who first time used our app on given date\\n cohort = df[(df['isFirst']==True) & (df['date']==start_date)].loc[:, 'uid']\\n ret_rates = {}\\n for day in range_date(start_date, end_date):\\n count_day = len(set(cohort) - (set(cohort) - set(DAU[day])))\\n ret_rates[day] = count_day \\/ cohort.shape[0] * 100\\n return ret_rates\\n\\nrates = {}\\nfor day in [date(2016,2,4), date(2016,2,10), date(2016,2,14)]:\\n rates[day] = retention_rate(day)\\n\\n# get retention data for each of the dates: Feb 4th, Feb 10th, and Feb 14th\\nsns.set(font_scale=1.4)\\nfig, ax = plt.subplots(figsize=(15,10))\\nplt.xticks(rotation=30)\\nplt.plot(pd.DataFrame(rates))\\nax.legend(['Feb 4th', 'Feb 10th', 'Feb 14th'])\\nax.set_title('Daily Retention Curve')\\nax.set_ylabel('Percentage of users retained');\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTwo interesting things:\\n1. A very clear up-and-down pattern. Specifically, down times are Fridays, Saturdays, and Sundays, with Saturdays at the bottom of valley.\\n2. A also very clear growing trend at February. In other words, our user base is growing.\\n2. Daily Retention Curve\\nCalculate the daily retention curve for users who used the app for the first time on the following dates: Feb 4th, Feb 10th, and Feb 14th. Also, show the number of users from each cohort.\\nDaily retention curve is defined as the % of users from the cohort, who used the product that day\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Common stopwords in tweets\\nFirst we will analyze tweets with class 0.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncorpus=create_corpus(0)\\n\\ndic=defaultdict(int)\\nfor word in corpus:\\n if word in stop:\\n dic[word]+=1\\n \\ntop=sorted(dic.items(), key=lambda x:x[1],reverse=True)[:10] \\n\\n\\nx,y=zip(*top)\\nplt.bar(x,y)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Book\\/chap2\\/chap2_basics.ipynb\\\".\\nThe first task is:\\nThe reason for the error is that the sqrt function is not a part of\\ncore Python. But it is a part of the NumPy module discussed earlier. To\\nmake the NumPy library available to the script, you need to add the\\nstatement import numpy as np. Then, when you call a NumPy function,\\nyou need to write the function with the np. prefix. Failure to do\\neither will result in a error message. Now we can run the script.\\nipython\\nIn [10]: run twoPointDistance.py\\nIn [11]: dr\\nOut[11]: 34.48\\nThe script works as expected.\\nThe reason we do not have to import NumPy when working in the IPython\\nshell is that it is done automatically when the IPython shell is\\nlaunched. Similarly, the package MatPlotLib is also automatically loaded\\n(imported) when IPython is launched. However, when a script or program\\nis executed, it is run on its own outside the IPython shell, even if the\\ncommand to run the script is executed from the IPython shell.\\nLine continuation\\nFrom time to time, a line of code in a script will be unusually long,\\nwhich can make the code difficult to read. In such cases, it is\\nadvisable to split the code onto several lines. For example, line 7 in\\nthe preceding script could be written as\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndr = np.sqrt( (x2-x1)**2 \\n + (y2-y1)**2 \\n + (z2-z1)**2 )\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"1.1 Working with a corpus\\/1.1.2. Extracting plain text from text-embedded PDFs.ipynb\\\".\\nThe first task is:\\nSo now we want to apply our procedure to each of these files: \\n* open the file, \\n* extract the text with slate,\\n* join the pages together into a single string,\\n* create a new text file,\\n* and write the string into that file.\\nIt's a good idea to create a new folder to hold the new text files.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntext_basepath = '..\\/data\\/PDFs_extracted'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"And the columns that are available for exemplary GSM:\\n\",\"targets\":\"gse.gsms[\\\"GSM143385\\\"].columns\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Using `OrderedDict()` to have the legend ordered later on when plotting the results \\nunis = OrderedDict()\\nfor row in table.find_all('tr')[1:]:\\n data = row.text.split('\\\\n')\\n unis[data[1]] = [money.split('[')[0] for money in data[2:-1]]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreate a dictionary to store the data from the table\\nThe dictionary format is such that the key is the university name, and the value is a list of strings indicating their annual endowment.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!cd $buildDir; \\\\\\n SIPSim fragments \\\\\\n $genomeDir\\/genome_index.txt \\\\\\n --fp $genomeDir \\\\\\n --fr ..\\/..\\/515F-806R.fna \\\\\\n --fld skewed-normal,9000,2500,-5 \\\\\\n --flr None,None \\\\\\n --nf 10000 \\\\\\n --np 24 \\\\\\n 2> ampFrags.log \\\\\\n > ampFrags.pkl \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreating input files (eg., fragments & communities)\\nSimulating fragments\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2.1\\/tutorials\\/pitch_yaw.ipynb\\\".\\nThe first task is:\\nand also with the line-of-sight along the x-axis.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nafig, mplfig = b.plot(time=0.0, fc='teffs', ec='none', x='ws', y='vs', show=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%R -h 350 -w 750\\n\\ndf = read.delim('OTU_PCR_sub.txt', sep='\\\\t')\\n\\n\\np = ggplot(df, aes(BD_mid, rel_abund, fill=taxon)) +\\n geom_area(stat='identity', position='fill') +\\n scale_x_continuous(expand=c(0,0)) +\\n scale_y_continuous(expand=c(0,0)) +\\n labs(x='Buoyant density') +\\n labs(y='Taxon relative abundances') +\\n facet_grid(library ~ .) +\\n theme_bw() +\\n theme( \\n text = element_text(size=16),\\n axis.title.y = element_text(vjust=1), \\n axis.title.x = element_blank()\\n )\\np\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNotes\\n\\nThe table is in the same format as with the original OTU table, but the counts and relative abundances should be altered.\\n\\nPlotting\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"A bit confused, isn'it? Anyway, it's clear that daily returns span over different ranges over time and across stocks, with several positive and negative spikes. To measure that variability, volatility, or standard deviation of returns, is often used.\\nBut volatility depends on calculation period and frequency. So, a long-term volatility, for instance computed on a 5 years period...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# We annualize the volatility multiplying it by (the root of) 260, which is a standard that approximates business days in a year\\nprices.fillna(method='pad').pct_change().rolling(1200).std().apply(lambda x: x * 260 ** 0.5).plot(figsize=(10, 8), title='Stock 5-years rolling volatility (annualized)');\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!rm ${PIPELINE_NAME}.tar.gz\\n!tfx pipeline compile \\\\\\n --engine=kubeflow \\\\\\n --pipeline_path=tfx_pipeline\\/runner.py \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCompile the TFX pipeline using the TFX CLI\\nUse the TFX CLI to compile the TFX pipeline to the KFP format, which allows the pipeline to be deployed and executed on AI Platform Pipelines. The output is a .tar.gz package containing an Argo definition of your pipeline.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"2 Supervised learning\\/Homework\\/10 1nn vs random forest\\/1NN против RandomForest.ipynb\\\".\\nThe first task is:\\nЦелью задания будет реализовать самый простой метрический классификатор — метод ближайшего соседа, а также сравнить качество работы реализованного вами 1NN с RandomForestClassifier из sklearn на 1000 деревьях.\\nЗадание 1\\nРеализуйте самостоятельно метод одного ближайшего соседа с евклидовой метрикой для задачи классификации. Можно не извлекать корень из суммы квадратов отклонений, т.к. корень — монотонное преобразование и не влияет на результат работы алгоритма.\\nНикакой дополнительной работы с признаками в этом задании делать не нужно — мы еще успеем этим заняться в других курсах. Ваша реализация может быть устроена следующим образом: можно для каждого классифицируемого объекта составлять список пар (расстояние до точки из обучающей выборки, метка класса в этой точке), затем сортировать этот список (по умолчанию сортировка будет сначала по первому элементу пары, затем по второму), а затем брать первый элемент (с наименьшим расстоянием).\\nСортировка массива длиной N требует порядка N log N сравнений (строже говоря, она работает за O(N log N)). Подумайте, как можно легко улучшить получившееся время работы. Кроме простого способа найти ближайший объект всего за N сравнений, можно попробовать придумать, как разбить пространство признаков на части и сделать структуру данных, которая позволит быстро искать соседей каждой точки. За выбор метода поиска ближайших соседей в KNeighborsClassifier из sklearn отвечает параметр algorithm — если у вас уже есть некоторый бэкграунд в алгоритмах и структурах данных, вам может быть интересно познакомиться со структурами данных ball tree и kd tree.\\nДоля ошибок, допускаемых 1NN на тестовой выборке, — ответ в задании 1.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef euclidian_metric(x, y):\\n return np.sqrt( np.sum((x - y)**2) )\\n\\ny_pred_knn = []\\nfor test_value in X_test:\\n ind_min_metric = 0\\n min_metric = euclidian_metric(test_value, X_train[0])\\n \\n for index, train_value in enumerate(X_train):\\n metric = euclidian_metric(test_value, train_value)\\n if metric < min_metric:\\n min_metric = metric\\n ind_min_metric = index\\n \\n y_pred_knn.append(y_train[ind_min_metric])\\n\\n#Accuracy\\nknn_err_rate = 1 - accuracy_score(y_test, y_pred_knn)\\nprint('1nn classifier error: ' + str(knn_err_rate))\\n\\nwith open('answer1.txt', 'w') as fout:\\n fout.write(str(knn_err_rate))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"After exploring the survival statistics visualization, fill in the missing code below so that the function will make your prediction.\\nMake sure to keep track of the various features and conditions you tried before arriving at your final prediction model.\\nHint: You can start your implementation of this function using the prediction code you wrote earlier from predictions_2.\\n\",\"targets\":\"def predictions_3(data):\\n \\\"\\\"\\\" Model with multiple features. Makes a prediction with an accuracy of at least 80%. \\\"\\\"\\\"\\n \\n predictions = []\\n for _, passenger in data.iterrows():\\n \\n #If passenger was female predict survived\\n if passenger['Sex'] == 'female':\\n #If female was in 3rd class & above 20\\n if passenger['Pclass'] == 3 and passenger['Age'] > 20:\\n predictions.append(0)\\n #Else predict survived\\n else:\\n predictions.append(1)\\n \\n elif passenger['Age'] < 10:\\n #If the passenger was not female, below 10 but in 3rd class predict died\\n if passenger['Pclass'] == 3:\\n predictions.append(0)\\n #Else predict survived\\n else:\\n predictions.append(1)\\n \\n #otherwise predict passenger died \\n else:\\n predictions.append(0)\\n \\n # Return our predictions\\n return pd.Series(predictions)\\n\\n# Make the predictions\\npredictions = predictions_3(data)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!CLdb -- DRconsensus2fasta -h\\n\\n# writing out the consensus sequences\\n!cd $workDir; \\\\\\n CLdb -- DRconsensus2fasta > DR_consensus.fna\\n \\n# checking output \\n!cd $workDir; \\\\\\n head -n 6 DR_consensus.fna\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThat's it! Now, the CLdb.sqlite file contains the DR consensus sequences for each CRISPR locus\\nAssessing DR consensus seqs\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Getting the Tensorflow session and the input tensor.\\nsess = keras.backend.get_session()\\nnetwork_input_tensor = model.layers[0].input\\nnetwork_input_tensor\\n\\n# Getting the tensor that holds the actiations as the output of a layer.\\nactivation_tensor = conv_layer.output\\nactivation_tensor\\n\\nactivations = sess.run(activation_tensor, feed_dict={network_input_tensor: test_data[0:1]})\\nactivations.shape\\n\\nfor i in range(32):\\n plt.imshow(activations[0, ..., i])\\n plt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nGetting the activations and net inputs\\nIntermediary computation results, i.e. results are not part of the prediction cannot be directly retrieved from Keras. It possible to build a new model for which the intermediary result is the prediction, but this approach makes computation rather inefficient when several intermediary results are to be retrieved. Instead it is better to reach directly into the backend for this purpose.\\nActivations are still fairly straight forward as the relevant tensors can be retrieved as output of the layer.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Set MOSEK tolerances \\nfrom opfsdr import msk\\nmsk.options[msk.mosek.dparam.intpnt_co_tol_pfeas] = 1e-9 # default: 1e-8\\nmsk.options[msk.mosek.dparam.intpnt_co_tol_dfeas] = 1e-9 # default: 1e-8\\nmsk.options[msk.mosek.dparam.intpnt_co_tol_rel_gap] = 1e-8 # default: 1e-7\\n\\n# Solve semidefinite relaxation\\n%time sol = prob.solve(solver=\\\"mosek\\\")\\n\\nprint(\\\"Solver status: %s\\\" % sol['status'])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe semidefinite relaxation can be solved with MOSEK as follows:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"3b. Patterns in vector lengths?\\nFill in the missing code below to add a column called norm containing the length of each movie's embedding to our DataFrame containing all movies (all_movies_df).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# TODO: Your code goes here. Add the column \\\"norm\\\" to our movies dataframe.\\npart3.b.check()\\n\\n#_COMMENT_IF(PROD)_\\npart3.b.solution()\\n\\n#%%RM_IF(PROD)%%\\n# Silly incorrect soln\\nall_movies_df['norm'] = norms + 1\\npart3.b.check()\\n\\n#%%RM_IF(PROD)%%\\n# Correct (solution code)\\nall_movies_df['norm'] = norms\\npart3.b.check()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Below you can see the fields loaded and a count of the values per field;\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndf.count()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#### Propeller distribution for 30-35 bp segment\\nplt.title('Propeller distribution for 30-35 bp segment')\\n\\n### Bound DNA ###\\n\\n## calculation of parameter distribution for the segment\\nvalues, density = pdna.parameter_distribution('propeller', [30, 35], bins=20, merge=True, merge_method='mean')\\n\\n## plot distribution\\nplt.plot(values, density, label='bound DNA', c='k') # balck color => bound DNA\\n\\n### Free DNA ###\\n\\n## calculation of parameter distribution for the segment\\nvalues, density = fdna.parameter_distribution('propeller', [30, 35], bins=20, merge=True, merge_method='mean')\\n\\n## plot distribution\\nplt.plot(values, density, label='free DNA', c='r') # red color => free DNA\\n\\nplt.xlabel('Propeller ( $^o$)')\\nplt.ylabel('Density')\\nplt.legend()\\nplt.show()\\n\\n\\n#### Buckle distribution for 40-45 bp segment\\nplt.title('Buckle distribution for 40-45 bp segment')\\n\\n### Bound DNA ###\\n\\n## calculation of parameter distribution for the segment\\nvalues, density = pdna.parameter_distribution('buckle', [40, 45], bins=20, merge=True, merge_method='mean')\\n\\n## plot distribution\\nplt.plot(values, density, label='bound DNA', c='k') # balck color => bound DNA\\n\\n### Free DNA ###\\n\\n## calculation of parameter distribution for the segment\\nvalues, density = fdna.parameter_distribution('buckle', [40, 45], bins=20, merge=True, merge_method='mean')\\n\\n## plot distribution\\nplt.plot(values, density, label='free DNA', c='r') # red color => free DNA\\n\\nplt.xlabel('Buckle ( $^o$)')\\nplt.ylabel('Density')\\nplt.legend()\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nDistribution of local base-pairs parameters during MD simulations\\n\\n\\nAs shown in above plot of time vs propeller, comparison between bound and free DNA is very difficult. Therefore, to compare the parameters of either different DNAs or same DNAs in different environment or different segment of same DNAs, the distribution of parameters over the MD trajectory are sometime useful.\\n\\n\\nThe distribution could be calculated using the function dnaMD.DNA.parameter_distribution(...) as shown in the following examples.\\n\\n\\nThe normalized distribution is calculated using numpy.histogram(...).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"ATIVIDADE2\\/Lab1_Rev_Python_Numpy_AlgeLin.ipynb\\\".\\nThe first task is:\\n(1b) Indentações \\nNo Python a indentação faz o papel das chaves para determinar o bloco de comandos de uma função, condicional ou laço de repetição. O início de um bloco é definido pelo caractere \\\":\\\".\\nCan you write Python code for it?\\n\",\"targets\":\"\\nx = 10\\n\\nfor i in range(20):\\n # Início da repetição For\\n x = x + 1\\n if x%2 == 0:\\n # Instrução se condição verdadeira\\n x = x + 1\\n else:\\n # Instrução se a condição for falsa\\n x = x + 2\\n # Fim do bloco de repetição For\\nprint x # Isso está fora do for! Boa Ideia!\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Dans ces exemples, le moteur tourne aussi vite que possible (c'est le fonctionnement par défaut). Vous pouvez changer la vitesse maximale du moteur qui est enregistrée dans le registre moving_speed du moteur :\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n#COMPLETER : pour mettre le registre moving_speed du moteur m1 de votre robot poppy à 50\\npoppy. =50\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%time\\n# plot\\nfig,ax = plt.subplots(1,1,figsize=(8,6))\\n# ax.scatter(gr_all, ri_all, s=0.01, c='green')\\nax.scatter(gr_pk1, ri_pk1, s=0.01, c='orange',label='pk1')\\nax.scatter(gr_pk2, ri_pk2, s=0.01, c='green',label='pk2')\\nax.scatter(gr_pk3, ri_pk3, s=0.01, c='blue',label='pk3')\\nax.scatter(gr_pk4, ri_pk4, s=0.01, c='red',label='pk4')\\nax.set_xlim(-0.7,2.2)\\nax.set_ylim(-0.7,2.4)\\nax.set_xlabel('SDSS(g-r)')\\nax.set_ylabel('SDSS(r-i)')\\nax.set_title('CCD: gr vs ri all-pk1-pk2',fontdict={'fontsize': 14, 'fontweight': 'bold'})\\nax.legend(loc='best')\\nax.grid(True)\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCCD gr vs ri\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Benchmark Explainer\\n\",\"targets\":\"sp = benchmark.perturbation.SequentialPerturbation(explainer.model, explainer.masker, sort_order, perturbation)\\nxs, ys, auc = sp.model_score(shap_values, s)\\nsp.plot(xs, ys, auc)\\n\\nsort_order = 'negative'\\nperturbation = 'keep'\\n\\nsp = benchmark.perturbation.SequentialPerturbation(explainer.model, explainer.masker, sort_order, perturbation)\\nxs, ys, auc = sp.model_score(shap_values, s)\\nsp.plot(xs, ys, auc)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"As always, let's do imports and initialize a logger and a new bundle. See Building a System for more details.\\n\",\"targets\":\"%matplotlib inline\\n\\nimport phoebe\\nfrom phoebe import u # units\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\n\\nlogger = phoebe.logger('error')\\n\\nb = phoebe.default_binary()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# read in sample sheet\\n\\ndef read_sample_sheet(f, sep='\\\\t'):\\n data = False\\n data_lines = ''\\n for line in f:\\n if data:\\n if line.startswith('[') or line.strip() == '':\\n data = False\\n continue\\n data_lines += line\\n elif line.startswith('[Data]'):\\n data = True\\n continue\\n else:\\n continue\\n \\n data_df = pd.read_csv(StringIO(data_lines), sep = '\\\\t', comment='#')\\n return(data_df)\\n\\nwith open('.\\/example\\/example_sample_sheet.txt', 'r') as f:\\n ss_df = read_sample_sheet(f)\\n\\n# column for read prefixes\\n# column for sample names\\n# aggregate into dict\\n\\nss_df.head()\\n\\n\\nseq_dir = '.\\/example\\/reads\\/'\\n\\nfps = os.listdir(seq_dir)\\n\\nfiles_df = parse_ilm_fps_to_df(fps)\\n\\nfiles_df\\n\\ndef get_sample_reads_df_from_sample_sheet(ss_df, seq_dir, sample_col='Description', prefix_col='Sample_ID'):\\n sample_reads_dict = {}\\n \\n samples = list(set(ss_df[sample_col]))\\n \\n fps = os.listdir(seq_dir)\\n\\n files_df = parse_ilm_fps_to_df(fps)\\n \\n for s in samples:\\n # get the subset of sample sheet rows for that sample\\n sample_rows = ss_df.loc[ss_df[sample_col] == s,]\\n \\n f_fps = []\\n r_fps = []\\n \\n # iter across subset table and find file corresponding to each row\\n for idx, row in sample_rows.iterrows():\\n lane = 'L{0:03d}'.format(row['Lane']) \\n \\n f_fps.extend(files_df.loc[(files_df['Sample'] == row['Sample_ID']) & \\n (files_df['Lane'] == lane) &\\n (files_df['Read'] == 'R1'), 'File'].values)\\n \\n r_fps.extend(files_df.loc[(files_df['Sample'] == row['Sample_ID']) & \\n (files_df['Lane'] == lane) &\\n (files_df['Read'] == 'R2'), 'File'].values)\\n \\n f_fps = sorted(f_fps)\\n r_fps = sorted(r_fps)\\n \\n sample_reads_dict[s] = {'forward':...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nOption 2: read sample names and prefixes from sample sheet\\nThis option is in development\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Classification\\/Support Vector Machines for Energy-Efficiency Classification.ipynb\\\".\\nThe first task is:\\nAs you can see via the df.describe() method, the mean for our target variables Y1 and Y2 is approx 22 and 24 respectively. Since the data for y1 and y2 is continuous, we will use the following piece of code to convert it into either high or low.\\nWe do this by defining all those y1 and y2 values above or 20 are high and those below 20 are low. We then map 1 for high and 0 for low.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# handle Y1 and Y2 attrubte to binary [High Hl and CL; and Low HL and Cl]\\nhigh = df.Y1 >= 20\\nlow = df.Y1 < 20\\ndf.loc[high,'Y1'] = 1\\ndf.loc[low,'Y1'] = 0\\n\\nhigh2 = df.Y2 >= 20\\nlow2 = df.Y2 < 20\\ndf.loc[high2,'Y2'] = 1\\ndf.loc[low2,'Y2'] = 0\\n\\ndf.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Authentication\\n\",\"targets\":\"# Need to specify your Keycloak SSO username and password so that we can get a token\\n\\nimport getpass\\nusername = input('Username')\\npassword = getpass.getpass('Password')\\n\\n# Get token from Keycloak. This will have a finite lifetime.\\n# If your requests are getting a 401 error your token has probably expired.\\n\\ndata = {'grant_type': 'password', 'client_id': 'squonk-jobexecutor', 'username': username, 'password': password}\\nkresp = requests.post(keycloak_url, data = data)\\nj = kresp.json()\\ntoken = j['access_token']\\ntoken\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"AnimationEmbedding.ipynb\\\".\\nThe first task is:\\nNow simply creating an animation will lead to it being automatically embedded\\nin the notebook, without any further function calls:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nanimation.FuncAnimation(fig, animate, init_func=init,\\n frames=100, interval=20, blit=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Kursteilnehmer\\/Thierry Seiler\\/06 \\/01 Rückblick For-Loop-Übungen.ipynb\\\".\\nThe first task is:\\n5.Addiere alle Zahlen in der Liste\\nCan you write Python code for it?\\n\",\"targets\":\"\\nadded = 0\\n\\nfor number in numbers:\\n added += number\\n\\nprint(added)\\n\\n#Lösung:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"AC3b is a refinement of the AC3 algorithm which consists of the fact that if, when arc $(i,j)$ is being processed and the reverse arc $(j,i)$ is also in the queue, then consistency-checks can be saved because only support for the elements in $S_j^?$ has to be found (as opposed to support for all the elements in $D_j$ in the\\nAC3 algorithm). \\nAC3b inherits all its properties like $\\\\mathcal{O}(ed^3)$ time-complexity and $\\\\mathcal{O}(e + nd)$ space-complexity fron AC3 and where $n$ denotes the number of variables in the CSP, $e$ denotes the number of binary constraints and $d$ denotes the maximum domain-size of the variables.\\nArc-Heuristics for Arc-Consistency Algorithms\\nMany arc-heuristics can be devised, based on three major features of CSPs:\\n- the number of acceptable pairs in each constraint (the constraint size or satisfiability);\\n- the domain size;\\n- the number of binary constraints that each variable participates in, equal to the degree of the node of that variable in the constraint graph. \\nSimple examples of heuristics that might be expected to improve the efficiency of relaxation are:\\n- ordering the list of variable pairs by increasing relative satisfiability;\\n- ordering by increasing size of the domain of the variable $v_j$ relaxed against $v_i$;\\n- ordering by descending degree of node of the variable relaxed.\\nIn [3] are investigated the effects of these arc-heuristics in an empirical way, experimenting the effects of them on random CSPs. Their results demonstrate that the first two, later called sat up and dom j up for n-ary and binary CSPs respectively, significantly reduce the number of consistency-checks.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%psource dom_j_up\\n\\n%psource sat_up\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create a table as a model of a stochastic phenomenom\\nHere we create a single column table as a computational model of a die\\nwith each element of the table containing the number of dots on the side.\\nThis illustrates the simplest way of constructing a table, Table.with_column.\\nThen we define a function that models rolling a die. This illustrates the\\nuse of Table.sample\\nto take random sample of a table.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndie = Table().with_column('side', [1,2,3,4,5,6])\\ndie\\n\\n# Simulate the roll of a die by sampling from the die table\\ndef roll_die():\\n return die.sample(1)['side'][0]\\n\\n# roll it. Try this over and over and see what you get\\nroll_die()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# calculate the standard error of the mean of the total energy\\nstandard_error_total_energy = np.sqrt(etotal.var()) \\/ np.sqrt(sampling_iterations)\\nprint(standard_error_total_energy)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSimple Error Estimation on Time Series Data\\nA simple way to estimate the error of an observable is to use the standard error of the mean (SE) for $N$\\nuncorrelated samples:\\n\\\\begin{equation}\\n SE = \\\\sqrt{\\\\frac{\\\\sigma^2}{N}},\\n\\\\end{equation}\\nwhere $\\\\sigma^2$ is the variance\\n\\\\begin{equation}\\n \\\\sigma^2 = \\\\left\\\\langle x^2 - \\\\langle x\\\\rangle^2 \\\\right\\\\rangle\\n\\\\end{equation}\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"3D plot of field lines and data\\n\\nColor bar in nT\\nSpatial distance in meter\\nProfile data only reflects shape of anomaly and positivity\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfig = plt.figure()\\nax = fig.gca(projection='3d')\\n\\n# plot field lines\\nfor lx,ly,lz in zip(linex,liney,linez):\\n ax.plot(lx,ly,lz,'-',markersize=1)\\n\\n# plot map\\nax.scatter(x1,y1,z1,s=2,alpha=0.3)\\nBt = Ba1.reshape(xi.shape)*1e9 # contour and color scale in nT \\nc = ax.contourf(xi,yi,Bt,alpha=1,zdir='z',offset=z-max(radii)*2,cmap='jet',\\n levels=np.linspace(Bt.min(),Bt.max(),50,endpoint=True))\\nfig.colorbar(c)\\n\\n# auto-scaling for profile plot\\nptpmax = np.max((Ba2.ptp(),Ba3.ptp())) # dynamic range\\nautoscaling = np.max(radii) \\/ ptpmax\\n\\n# plot x-profile\\nax.scatter(x2,y2,z2,s=2,c='black',alpha=0.3)\\nax.plot(x2,Ba2*autoscaling,zs=ymax,c='black',zdir='y')\\n\\n# plot y-profile\\nax.scatter(x3,y3,z3,s=2,c='black',alpha=0.3)\\nax.plot(y3,Ba3*autoscaling,zs=xmin,c='black',zdir='x')\\n\\nax.set_xlabel('X')\\nax.set_ylabel('Y')\\nax.set_zlabel('Z')\\n\\nax.set_xlim(xmin, xmax)\\nax.set_ylim(ymin, ymax)\\nax.set_zlim(z-max(radii)*2, max(radii)*1.5)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Create two qubits\\nq0, q1 = cirq.GridQubit.rect(1, 2)\\n\\n# Create a circuit on these qubits using the parameters you created above.\\ncircuit = cirq.Circuit(\\n cirq.rx(a).on(q0),\\n cirq.ry(b).on(q1), cirq.CNOT(control=q0, target=q1))\\n\\nSVGCircuit(circuit)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n次のコードは、上記のパラメータを使用して 2 つの量子ビット回路を作成します。\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"BMLSwPython\\/CH01Learn.ipynb\\\".\\nThe first task is:\\nFitting a linear model fp1\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# starting with linear model where degree is 1\\n# polyfit() - best put that line into the chart so that it results in the smallest\\n# approximation error\\n\\nfp1, residuals, rank, sv, rcond = sp.polyfit(X, y, 1, full=True)\\nfp1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\" \\nAdd column MainProfiles\\n\",\"targets\":\"def add_column_main_profiles(column_name=\\\"MainProfiles\\\"):\\n def set_main_profiles(row):\\n boulder_name = row.name\\n main_profiles1_s = spb2018_df.loc[(spb2018_df[\\\"Boulderin nimi\\\"] == boulder_name), \\\"Boulderin pääprofiilit\\\"]\\n main_profiles2_s = spb2018_df.loc[(spb2018_df[\\\"Boulderin nimi.1\\\"] == boulder_name), \\\"Boulderin pääprofiilit.1\\\"]\\n main_profiles3_s = spb2018_df.loc[(spb2018_df[\\\"Boulderin nimi.2\\\"] == boulder_name), \\\"Boulderin pääprofiilit.2\\\"]\\n main_profiles_s = main_profiles1_s.append(main_profiles2_s).append(main_profiles3_s)\\n main_profiles = \\\",\\\".join(main_profiles_s)\\n # Clean main_profiles\\n main_profiles = \\\",\\\".join(sorted(list(set([main_profile.strip().lower() for main_profile in main_profiles.split(\\\",\\\")]))))\\n return main_profiles\\n \\n boulder_details_df[column_name] = boulder_details_df.apply(set_main_profiles, axis=1)\\n \\nadd_column_main_profiles()\\nboulder_details_df.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Contour plots of 2d wavefunctions\\nThe wavefunction of a 2d quantum well is:\\n$$ \\\\psi_{n_x,n_y}(x,y) = \\\\frac{2}{L}\\n \\\\sin{\\\\left( \\\\frac{n_x \\\\pi x}{L} \\\\right)} \\n \\\\sin{\\\\left( \\\\frac{n_y \\\\pi y}{L} \\\\right)} $$\\nThis is a scalar field and $n_x$ and $n_y$ are quantum numbers that measure the level of excitation in the x and y directions. $L$ is the size of the well.\\nDefine a function well2d that computes this wavefunction for values of x and y that are NumPy arrays.\\n\",\"targets\":\"def well2d(x, y, nx, ny, L=1.0):\\n \\\"\\\"\\\"Compute the 2d quantum well wave function.\\\"\\\"\\\"\\n sci=2\\/L*np.sin((nx*np.pi*x)\\/L)*np.sin((ny*np.pi*y)\\/L)\\n return sci\\n\\npsi = well2d(np.linspace(0,1,10), np.linspace(0,1,10), 1, 1)\\nassert len(psi)==10\\nassert psi.shape==(10,)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# help(range)\\n\\nLs = range(-10,10,2)\\nprint(Ls)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNOTA: Anche in questo caso esiste una funzione built-in di python chiamata range().\\nLeggere con l'help in linea la documentazione di range().\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Parameter exploration - psyrun.ipynb\\\".\\nThe first task is:\\nThis immediatly runs the first (and only the first) parameter assignment as a way to check that nothing crashes. Now let us run the full task.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%%sh\\npsy-doit cc1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"BNU 1\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n\\nmemfig = memory_function('\\/data\\/BNU_sub\\/BNU_single\\/mem.txt', 'BNU 1 single')\\ndiskfig = disk_function('\\/data\\/BNU_sub\\/BNU_single\\/disk.txt', 'BNU 1 single')\\ncpufig = cpu_function('\\/data\\/BNU_sub\\/BNU_single\\/cpu.txt', 'BNU 1 single')\\nmemfig.show()\\ndiskfig.show()\\ncpufig.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"A function for getting the headers from a csv file.\\n\",\"targets\":\"def get_headers(csv_file=citation_csv):\\n with open(csv_file) as csvfile:\\n reader = reader = csv.DictReader(csvfile)\\n for row in reader:\\n return list(row.keys())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"<\\/a>\\nIsentropic Interpolation\\nNow let's take what we've downloaded, and use it to make an isentropic map. In this case, we're interpolating from one vertical coordinate, pressure, to another: potential temperature. MetPy has a function isentropic_interpolation that can do this for us. First, let's start with a few useful imports.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport metpy.calc as mpcalc\\nfrom metpy.units import units\\nimport numpy as np\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"By default, the notebook downloads a preprocessed version of this dataset, but\\nyou may use the original dataset and re-run the processing steps if\\ndesired.\\nIn the original dataset, each comment is labeled with the percentage\\nof raters who believed that a comment corresponds to a particular\\nidentity. For example, a comment might be labeled with the following:\\n{ male: 0.3, female: 1.0, transgender: 0.0, heterosexual: 0.8,\\nhomosexual_gay_or_lesbian: 1.0 }.\\nThe processing step groups identity by category (gender,\\nsexual_orientation, etc.) and removes identities with a score less\\nthan 0.5. So the example above would be converted to the following:\\nof raters who believed that a comment corresponds to a particular\\nidentity. For example, the comment above would be labeled with the\\nfollowing:\\n{ gender: [female], sexual_orientation: [heterosexual,\\nhomosexual_gay_or_lesbian] }\\nDownload the dataset.\\n\",\"targets\":\"download_original_data = False #@param {type:\\\"boolean\\\"}\\n\\nif download_original_data:\\n train_tf_file = tf.keras.utils.get_file('train_tf.tfrecord',\\n 'https:\\/\\/storage.googleapis.com\\/civil_comments_dataset\\/train_tf.tfrecord')\\n validate_tf_file = tf.keras.utils.get_file('validate_tf.tfrecord',\\n 'https:\\/\\/storage.googleapis.com\\/civil_comments_dataset\\/validate_tf.tfrecord')\\n\\n # The identity terms list will be grouped together by their categories\\n # (see 'IDENTITY_COLUMNS') on threshold 0.5. Only the identity term column,\\n # text column and label column will be kept after processing.\\n train_tf_file = util.convert_comments_data(train_tf_file)\\n validate_tf_file = util.convert_comments_data(validate_tf_file)\\n\\nelse:\\n train_tf_file = tf.keras.utils.get_file('train_tf_processed.tfrecord',\\n 'https:\\/\\/storage.googleapis.com\\/civil_comments_dataset\\/train_tf_processed.tfrecord')\\n validate_tf_file = tf.keras.utils.get_file('validate_tf_processed.tfrecord',\\n 'https:\\/\\/storage.googleapis.com\\/civil_comments_dataset\\/validate_tf_processed.tfrecord')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"10_dx_interest_rate_swaps.ipynb\\\".\\nThe first task is:\\nAnd the calibration itself.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom scipy.optimize import fmin\\n\\nopt = fmin(srd_forward_error, (1.0, 0.7, 0.2),\\n maxiter=1000, maxfun=1000)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"3 rows in the resampled database are nan's. Just drop them.\\n\",\"targets\":\"rdf = rdf.dropna()\\n\\nresampled_rate = 1 \\/ np.diff(rdf['motionTimestamp_sinceReboot'])\\n\\nplt.hist(resampled_rate, bins=20)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"PASSED<\\/span>\\n\\n你的估算状态值函数与该策略对应的真状态值函数有多接近？ \\n你可能注意到了，有些状态值不是智能体估算的。因为根据该策略，智能体不会经历所有状态。在 TD 预测算法中，智能体只能估算所经历的状态对应的值。\\n第 2 部分：TD 控制 - Sarsa\\n在此部分，你将自己编写 Sarsa 控制算法的实现。\\n你的算法将有四个参数：\\n- env：这是 OpenAI Gym 环境的实例。\\n- num_episodes：这是通过智能体-环境互动生成的阶段次数。\\n- alpha：这是更新步骤的步长参数。\\n- gamma：这是折扣率。它必须是在 0 到 1（含）之间的值，默认值为：1。\\n该算法会返回以下输出结果：\\n\\nQ：这是一个字典（一维数组），其中 Q[s][a] 是状态 s 和动作 a 对应的估算动作值。\\n\\n请完成以下代码单元格中的函数。\\n（你可以随意定义其他函数，以帮助你整理代码。）\\n\",\"targets\":\"def update_Q(Qsa, Qsa_next, reward, alpha, gamma):\\n \\\"\\\"\\\" updates the action-value function estimate using the most recent time step \\\"\\\"\\\"\\n return Qsa + (alpha * (reward + (gamma * Qsa_next) - Qsa))\\n\\ndef epsilon_greedy_probs(env, Q_s, i_episode, eps=None):\\n \\\"\\\"\\\" obtains the action probabilities corresponding to epsilon-greedy policy \\\"\\\"\\\"\\n epsilon = 1.0 \\/ i_episode\\n if eps is not None:\\n epsilon = eps\\n policy_s = np.ones(env.nA) * epsilon \\/ env.nA\\n policy_s[np.argmax(Q_s)] = 1 - epsilon + (epsilon \\/ env.nA)\\n return policy_s\\n\\nimport matplotlib.pyplot as plt\\n%matplotlib inline\\n\\ndef sarsa(env, num_episodes, alpha, gamma=1.0):\\n # initialize action-value function (empty dictionary of arrays)\\n Q = defaultdict(lambda: np.zeros(env.nA))\\n # initialize performance monitor\\n plot_every = 100\\n tmp_scores = deque(maxlen=plot_every)\\n scores = deque(maxlen=num_episodes)\\n # loop over episodes\\n for i_episode in range(1, num_episodes+1):\\n # monitor progress\\n if i_episode % 100 == 0:\\n print(\\\"\\\\rEpisode {}\\/{}\\\".format(i_episode, num_episodes), end=\\\"\\\")\\n sys.stdout.flush() \\n # initialize score\\n score = 0\\n # begin an episode, observe S\\n state = env.reset() \\n # get epsilon-greedy action probabilities\\n policy_s = epsilon_greedy_probs(env, Q[state], i_episode)\\n # pick action A\\n action = np.random.choice(np.arange(env.nA), p=policy_s)\\n # limit number of time steps per episode\\n for t_step in np.arange(300):\\n # take action A, observe R, S'\\n next_state, reward, done, info = env.step(action)\\n # add reward to score\\n score += reward\\n if not done:\\n # get epsilon-greedy action probabilities\\n policy_s = epsilon_greedy_probs(env, Q[next_state], i_episode)\\n # pick next action A'\\n next_action = np.random.choice(np.arange(env.nA), p=policy_s)\\n # update TD estimate of Q\\n...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"06._Scipy.ipynb\\\".\\nThe first task is:\\nRestrições envolvendo propriedades de matrizes são tratados como exceções. Python é uma linguagem que suporta exceções, que podem ser capturadas em tempo de execução de tratadas de acordo¹. No exemplo abaixo, uma exceção, ValueError, é gerada ao tentarmos computar o determinante de uma matrix que não é quadrada:\\n¹ Ver Errors and Exceptions para detalhes.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nlinalg.det(ones((3, 4)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"According to the OPSD energy hierarchy, the power plants whose energy_source_level_2 is either Storage or Other fossil fuels do not belong to the class of renewable-energy facilities. Therefore, we can remove them.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndrop_mask = DE_renewables['energy_source_level_2'].isin(['Other fossil fuels', 'Storage'])\\nDE_renewables.drop(DE_renewables.index[drop_mask], axis=0, inplace=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Binary Tree Path Sum II\\n\\nYour are given a binary tree in which each node contains a value. Design an algorithm to get all paths which sum to a given value. The path does not need to start or end at the root or a leaf, but it must go in a straight line down.\\nhttp:\\/\\/www.lintcode.com\\/en\\/problem\\/binary-tree-path-sum-ii\\/\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n\\\"\\\"\\\"\\nDefinition of TreeNode:\\nclass TreeNode:\\n def __init__(self, val):\\n self.val = val\\n self.left, self.right = None, None\\n\\\"\\\"\\\"\\nclass Solution:\\n # @param {TreeNode} root the root of binary tree\\n # @param {int} target an integer\\n # @return {int[][]} all valid paths\\n def binaryTreePathSum2(self, root, target):\\n # Write your code here\\n path, result = [], []\\n self.dfs(root, path, result, 0, target)\\n return result\\n \\n \\n \\n def dfs(self, root, path, result, l, target):\\n if root is None:\\n return \\n path.append(root.val)\\n temp = target\\n for i in xrange(l, -1, -1):\\n temp -= path[i]\\n if temp == 0:\\n result.append(path[i:])\\n \\n self.dfs(root.left, path, result, l + 1, target)\\n self.dfs(root.right, path, result, l + 1, target)\\n \\n path.pop()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Big-Data-and-Spark\\/.ipynb_checkpoints\\/lecture_notes-checkpoint.ipynb\\\".\\nThe first task is:\\nWhat about this?\\nCan you write Python code for it?\\n\",\"targets\":\"\\nsc.textFile('input.txt') \\\\\\n .flatMap(lambda x: x.split()) \\\\\\n .count()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Cross sections and their uncertainties are stored in the xsVal and xsUnc dictionaries, where the keys represent a specific universe and the corresponding values are dictionaries.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# The keys within the nested dictionary describe the isotope, reaction and special flag\\nprint(mdx.xsVal['0'].keys())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Constants\\nThe Astropy package also includes a whole bunch of built-in constants to make your life easier.\\nA complete list of the built-in constants can be found here.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nconst.G\\n\\nconst.M_sun\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# set loss function to output squared\\nout = rgnet(X)\\nloss = torch.mean(out**2, dim=0)\\n\\n# Backprop\\nloss.backward()\\nprint(rgnet[0][1][0].bias.grad)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nBackprop\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"11_realtime\\/evaluation.ipynb\\\".\\nThe first task is:\\nImpact of different variables\\nLet's see how the model behaves with respect to specific feature values\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%%bigquery df\\nSELECT\\n ROUND(predicted_ontime.scores[OFFSET(0)], 2) AS prob_ontime,\\n AVG(CAST(dep_delay AS FLOAT64)) AS dep_delay,\\n STDDEV(CAST(dep_delay AS FLOAT64)) AS std_dep_delay,\\n AVG(CAST(taxi_out AS FLOAT64)) AS taxi_out,\\n STDDEV(CAST(taxi_out AS FLOAT64)) AS std_taxi_out\\nFROM dsongcp.ch10_automl_evaluated\\nGROUP BY prob_ontime\\nORDER BY prob_ontime ASC\\n\\ndf.plot(x='prob_ontime', y='dep_delay', ylabel='seconds');\\n\\n%%bigquery df2\\nSELECT\\n ROUND(CAST(dep_delay AS FLOAT64), 0) AS dep_delay,\\n AVG(predicted_ontime.scores[OFFSET(0)]) AS prob_ontime,\\nFROM dsongcp.ch10_automl_evaluated\\nGROUP BY dep_delay\\nORDER BY dep_delay ASC\\n\\ndf2.plot(x='dep_delay', y='prob_ontime', xlim=[-10,100]);\\n\\ndf.plot(x='prob_ontime', y='dep_delay', yerr='std_dep_delay', ylabel='seconds');\\n\\ndf.plot(x='prob_ontime', y='taxi_out', yerr='std_taxi_out', ylabel='seconds');\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"(Moderate) success! The random forest classifier gives a reasonable accuracy, precision, etc. There are more false negatives than the SVC, but the false positive rate is much lower. Since we prefer false negatives to false positives, this is not too bad.\\nWe now test the prediction on our test set and see that the results are similar to those on the validation set.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nrfc = RandomForestClassifier(n_estimators=100, verbose=1, n_jobs=-1)\\nrfc.fit(Xtrain_cat, ytrain_cat)\\nypred = rfc.predict(Xtest_cat)\\nprint confusion_matrix(ytest_cat, ypred)\\ngetstats(confusion_matrix(ytest_cat, ypred))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Adding Datasets\\nNow we'll add radial velocity and mesh datasets. We'll add two identical datasets for RVs so that we can have one computed dynamically and the other computed numerically (these options will need to be set later).\\n\",\"targets\":\"b.add_dataset('rv', times=np.linspace(0,2,201), dataset='dynamicalrvs') \\n\\nb.add_dataset('rv', times=np.linspace(0,2,201), dataset='numericalrvs')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Building a Custom Widget\\nThe widget framework is built on top of the Comm framework (short for communication). The Comm framework is a framework that allows you send\\/receive JSON messages to\\/from the front-end (as seen below).\\n\\nTo create a custom widget, you need to define the widget both in the back-end and in the front-end. \\nBuilding a Custom Widget\\nTo get started, you'll create a simple hello world widget. Later you'll build on this foundation to make more complex widgets.\\nBack-end (Python)\\nDOMWidget and Widget\\nTo define a widget, you must inherit from the Widget or DOMWidget base class. If you intend for your widget to be displayed in the IPython notebook, you'll need to inherit from the DOMWidget. The DOMWidget class itself inherits from the Widget class. The Widget class is useful for cases in which the Widget is not meant to be displayed directly in the notebook, but instead as a child of another rendering environment. For example, if you wanted to create a three.js widget (a popular WebGL library), you would implement the rendering window as a DOMWidget and any 3D objects or lights meant to be rendered in that window as Widgets.\\n_view_name\\nInheriting from the DOMWidget does not tell the widget framework what front-end widget to associate with your back-end widget. Instead, you must tell it yourself by defining a specially named Traitlet, _view_name (as seen below).\\n\",\"targets\":\"from IPython.html import widgets\\nfrom IPython.utils.traitlets import Unicode\\n\\nclass HelloWidget(widgets.DOMWidget):\\n _view_name = Unicode('HelloView', sync=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Actually, the deviation is 1\\/100 of this, so let's adjust...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nx=data['Year']\\ny=data['J-D']\\/100.0\\nplot(x,y,'-o')\\nxlabel('Year')\\nylabel('Temperature Deviation')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"And we are ready to train the model and use it for predictions!\\nThere's really nothing special about this code, it's virtually the same as the one we used earlier for Linear Regression:\\n\",\"targets\":\"n_epochs = 1000\\nbatch_size = 50\\nn_batches = int(np.ceil(m \\/ batch_size))\\n\\nwith tf.Session() as sess:\\n sess.run(init)\\n\\n for epoch in range(n_epochs):\\n for batch_index in range(n_batches):\\n X_batch, y_batch = random_batch(X_train, y_train, batch_size)\\n sess.run(training_op, feed_dict={X: X_batch, y: y_batch})\\n loss_val = loss.eval({X: X_test, y: y_test})\\n if epoch % 100 == 0:\\n print(\\\"Epoch:\\\", epoch, \\\"\\\\tLoss:\\\", loss_val)\\n\\n y_proba_val = y_proba.eval(feed_dict={X: X_test, y: y_test})\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# add headers\\ncitation_counts_ = [('Count', CITATION_CHARGE, ), ] + citation_counts\\n# create table with make_table\\nmake_table(citation_counts_)\\n# apply some styles to the table after it is created\\nset_column_style(0, width='100', bold=True, color='hsla(225, 80%, 94%, 1)')\\nset_column_style(1, width='100')\\ndisplay(HTML(render()._repr_html_()))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNB: A Pelican plug-in I am using to create posts with notebooks is adding extra ';' characters likely secondary to HTML escaping during rendering.\\nIt is still easier on the eyes than reading a list of tuples!\\nThe following code is particular to Jupyter notebooks for displaying HTML.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Check out of sample prediction ability of the model.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ny_pred_samples = mf.compute_model_mean_sample(y_test_coo.row, y_test_coo.col, sample_dict, \\n thin=10, n_discard=0)\\ny_pred_mean = np.mean(y_pred_samples, 1)\\nmse = np.mean((y_pred_mean - y_test_coo.data) ** 2)\\nR_sq = 1 - mse \\/ np.var(y_test_coo.data)\\nprint(\\\"The matrix factorization model explains {:.2f}% of variability in the test data.\\\".format(R_sq * 100))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"3. Plot Metrics\\n1. Mean Squared Error\\nDuring training, the model's performance is constantly being measured against both our training data and the validation data that we set aside earlier. Training produces a log of data that tells us how the model's performance changed over the course of the training process.\\nThe following cells will display some of that data in a graphical form:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Draw a graph of the loss, which is the distance between\\n# the predicted and actual values during training and validation.\\nloss = history_1.history['loss']\\nval_loss = history_1.history['val_loss']\\n\\nepochs = range(1, len(loss) + 1)\\n\\nplt.plot(epochs, loss, 'g.', label='Training loss')\\nplt.plot(epochs, val_loss, 'b', label='Validation loss')\\nplt.title('Training and validation loss')\\nplt.xlabel('Epochs')\\nplt.ylabel('Loss')\\nplt.legend()\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\nDistribución de grados para la red proyectada de usuarios\\n\",\"targets\":\"degrees_projected_graph_users = list(projected_graph_users.degree().values())\\ndegrees_projected_graph_users = np.array(degrees_projected_graph_users)\\ndegrees_projected_graph_users = degrees_projected_graph_users[np.nonzero(degrees_projected_graph_users)]\\nsns.distplot(degrees_projected_graph_users)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"<< CHANGES START HERE >>\\nData augmentation function\\nWe now define a function to apply random data augmentation to a mini-batch of images.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef augment_train_batch(batch_X, batch_y):\\n n = len(batch_X)\\n \\n # Random crop\\n crop = np.random.randint(low=0, high=16, size=(n, 2))\\n batch_X_cropped = np.zeros((n, 3, 64, 64), dtype=np.float32)\\n for i in range(n):\\n batch_X_cropped[i, :, :, :] = batch_X[i, :, crop[i, 0]:crop[i, 0]+64, crop[i, 1]:crop[i, 1]+64]\\n batch_X = batch_X_cropped\\n \\n # Random horizontal flip\\n flip_h = np.random.randint(low=0, high=2, size=(n,)) == 1\\n batch_X[flip_h, :, :, :] = batch_X[flip_h, :, :, ::-1]\\n \\n # Random colour offset; normally distributed, std-dev 0.1\\n colour_offset = np.random.normal(scale=0.1, size=(n, 3))\\n \\n batch_X += colour_offset[:, :, None, None]\\n \\n return batch_X, batch_y\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Project 2- Data Analysis with Python\\/titanic_project.ipynb\\\".\\nThe first task is:\\nIt can be observed that younger and older passengers regardless of their gender had an higher survival ratio than middle aged passengers.\\n3.4 Did the age considering the gender determine the chances of survival?\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Count the PassengerId grouped by age and gender and save ad dataframe\\ndf=pd.DataFrame({'count' : titanic.groupby([\\\"Age\\\", \\\"Sex\\\"])[\\\"PassengerId\\\"].count()}).reset_index()\\n\\n# Take from df values which belong to men and save as new dataframe\\ndf_male=df.ix[(df['Sex']=='male')]\\n# Take from df values which belong to women and save as new dataframe\\ndf_women=df.ix[(df['Sex']=='female')]\\n\\n# Create dictionary with age of men as the key and the count of men in this age group as value\\nmale_by_age=dict(zip(df_male[\\\"Age\\\"], df_male[\\\"count\\\"]))\\n# Create dictionary with age of women as the key and the count of women in this age group as value\\nfemale_by_age=dict(zip(df_women[\\\"Age\\\"], df_women[\\\"count\\\"]))\\n\\n#Count the PassengerId grouped by survival, age and gender and save as dataframe\\ndf=pd.DataFrame({'count' : titanic.groupby( [\\\"Survived\\\",\\\"Age\\\", \\\"Sex\\\"])[\\\"PassengerId\\\"].count()}).reset_index()\\n\\n#Create two dictionaries in which the keys are the age of men\\/women and the normalized count of men\\/women in this age group as value\\nmale_by_age_survived={}\\nfemale_by_age_survived={}\\nfor index, row in df.iterrows():\\n if row[\\\"Survived\\\"]==1:\\n if row[\\\"Sex\\\"]==\\\"male\\\":\\n male_by_age_survived.update(({row[\\\"Age\\\"]:row[\\\"count\\\"]\\/float(male_by_age[row[\\\"Age\\\"]])}))\\n else:\\n female_by_age_survived.update(({row[\\\"Age\\\"]:row[\\\"count\\\"]\\/float(female_by_age[row[\\\"Age\\\"]])}))\\n \\n# Plot the results\\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 5))\\naxes[0].bar(list(male_by_age_survived.keys()), list(male_by_age_survived.values()), align='center')\\naxes[0].set_xlabel('Age \\/ years')\\naxes[0].set_ylabel('Ration of survived men')\\naxes[0].set_title('Survival of male passengers by age')\\n\\naxes[1].bar(list(female_by_age_survived.keys()), list(female_by_age_survived.values()), align='center')\\naxes[1].set_xlabel('Age \\/ years')\\naxes[1].set_ylabel('Ration of survived women')\\naxes[1].set_title('Survival of female passengers by age')\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%time\\nimport torch\\nimport torch.nn as nn\\nimport torch.nn.functional as F\\nimport torch.optim as optim\\nfrom torchvision import datasets, transforms\\nfrom torch.autograd import Variable\\n\\n\\nloss_history = []\\nloss_history_2 = []\\nacc_history = []\\nrunning_loss = 0.0\\n\\ndef train(epoch):\\n model.train()\\n running_loss = 0.0\\n for batch_idx, (data, target) in enumerate(train_loader): # \\n # torch.LongTensor of size BATCH_SIZE\\n # [torch.FloatTensor of size 4x3x32x32] BATCH_SIZE* IMAGE SIZE\\n if use_cuda:\\n data, target = Variable(data.cuda(async=True)), Variable(target.cuda(async=True)) # On GPU \\n else: \\n data, target = Variable(data), Variable(target) \\n # You will get RuntimeError: expected CPU tensor (got CUDA tensor) if you dont do this \\n optimizer.zero_grad() \\n outputs = model(data)\\n if use_cuda:\\n loss = criterion(outputs, target).cuda() \\n# loss = F.nll_loss(outputs, target).cuda() \\n \\n else:\\n loss = criterion(outputs, target)\\n# loss = F.nll_loss(outputs, target) \\n\\n loss.backward()\\n optimizer.step() \\n running_loss += loss.data[0]\\n if batch_idx % 2000 == 1999: # print every 2000 mini-batches\\n print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss \\/ 2000))\\n loss_history.append(running_loss \\/ 2000)\\n running_loss = 0.0\\n \\n if batch_idx % 3000 == 0:\\n loss_history_2.append(loss.data[0])\\n lgr.info('Train Epoch: {} [{}\\/{} ({:.0f}%)]\\\\tLoss: {:.6f}'.format(\\n epoch, batch_idx * len(data), len(train_loader.dataset),\\n 100. * batch_idx \\/ len(train_loader), loss.data[0])) \\n \\nstart_time = time.time() \\n\\nfor epoch in range(1, N_EPOCHS):\\n print(\\\"Epoch %d\\\" % epoch)\\n train(epoch) \\n print('Finished Training epoch:' + str(epoch))\\nend_time = time.time()\\n\\n%matplotlib inline\\nimport...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nStart training in Batches\\nSee example here:\\nhttp:\\/\\/codegists.com\\/snippet\\/python\\/pytorch_mnistpy_kernelmode_python\\nhttps:\\/\\/github.com\\/pytorch\\/examples\\/blob\\/53f25e0d0e2710878449900e1e61d31d34b63a9d\\/mnist\\/main.py\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Convolution and Max Pooling Layer\\nConvolution layers have a lot of success with images. For this code cell, we should implement the function conv2d_maxpool to apply convolution then max pooling.\\n\",\"targets\":\"def conv2d_maxpool(x_tensor, conv_num_outputs, conv_ksize, conv_strides, pool_ksize, pool_strides):\\n \\\"\\\"\\\"\\n Apply convolution then max pooling to x_tensor\\n :param x_tensor: TensorFlow Tensor\\n :param conv_num_outputs: Number of outputs for the convolutional layer\\n :param conv_ksize: kernal size 2-D Tuple for the convolutional layer\\n :param conv_strides: Stride 2-D Tuple for convolution\\n :param pool_ksize: kernal size 2-D Tuple for pool\\n :param pool_strides: Stride 2-D Tuple for pool\\n : return: A tensor that represents convolution and max pooling of x_tensor\\n \\\"\\\"\\\"\\n #Implement Function\\n print(conv_ksize)\\n print(x_tensor.shape)\\n print(conv_num_outputs)\\n weights = tf.Variable(tf.truncated_normal((conv_ksize[0], conv_ksize[1], int(x_tensor.shape[3]), conv_num_outputs ),\\\\\\n mean=0, stddev=0.1))\\n bias = tf.Variable(tf.zeros(conv_num_outputs))\\n \\n print(conv_strides)\\n conv_layer = tf.nn.conv2d(x_tensor, weights, strides=[1, conv_strides[0], conv_strides[1], 1], padding = 'SAME')\\n conv_layer = tf.nn.bias_add(conv_layer, bias)\\n \\n conv_layer = tf.nn.relu(conv_layer)\\n \\n print(pool_ksize)\\n print(pool_strides)\\n conv_layer = tf.nn.max_pool(conv_layer, ksize=[1, pool_ksize[0], pool_ksize[1], 1], \\\\\\n strides=[1, pool_strides[0], pool_strides[1], 1], padding='SAME' )\\n \\n return conv_layer \\n\\ntests.test_con_pool(conv2d_maxpool)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%timeit get_related_podcasts_query_scikit('economics math statistics',5)\\n\\n%timeit get_related_podcasts_scikit(22,5)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTiming:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\n\",\"targets\":\"pos = np.array([.1]*10)\\nhallway = np.array([1, 1, 0, 0, 0, 0, 0, 0, 1, 0])\\n\\ndef bar_animate(nframe):\\n global pos\\n #if nframe == 0:\\n # return\\n\\n bar_plot(pos, ylim=(0,1.0))\\n plt.title('Step {}'.format(nframe + 1))\\n if nframe % 2 == 0:\\n pos = predict(pos, 1, .9, .05, .05)\\n else:\\n x = int((nframe\\/2) % len(hallway))\\n z = hallway[x]\\n pos = update(pos, z, .9, .2)\\n \\n\\nfig = plt.figure(figsize=(6.5, 2.5))\\nanimate('02_simulate.gif', bar_animate, fig=fig, frames=40, interval=85);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Custom Color Maps\\nThe main objective when plotting a Wigner function is to demonstrate that the underlying\\nstate is nonclassical, as indicated by negative values in the Wigner function. Therefore,\\nmaking these negative values stand out in a figure is helpful for both analysis and publication\\npurposes. Unfortunately, all of the color schemes used in Matplotlib (or any other plotting software)\\nare linear colormaps where small negative values tend to be near the same color as the zero values, and\\nare thus hidden. To fix this dilemma, QuTiP includes a nonlinear colormap function wigner_cmap\\nthat colors all negative values differently than positive or zero values. Below is a demonstration of how to use\\nthis function in your Wigner figures:\\n\",\"targets\":\"import matplotlib as mpl\\nfrom matplotlib import cm\\n\\npsi = (basis(10, 0) + basis(10, 3) + basis(10, 9)).unit()\\nxvec = np.linspace(-5, 5, 500)\\nW = wigner(psi, xvec, xvec)\\n\\nwmap = wigner_cmap(W) # Generate Wigner colormap\\nnrm = mpl.colors.Normalize(-W.max(), W.max())\\n\\nfig, axes = subplots(1, 2, figsize=(10, 4))\\nplt1 = axes[0].contourf(xvec, xvec, W, 100, cmap=cm.RdBu, norm=nrm)\\naxes[0].set_title(\\\"Standard Colormap\\\")\\ncb1 = fig.colorbar(plt1, ax=axes[0])\\n\\nplt2 = axes[1].contourf(xvec, xvec, W, 100, cmap=wmap) # Apply Wigner colormap\\naxes[1].set_title(\\\"Wigner Colormap\\\")\\ncb2 = fig.colorbar(plt2, ax=axes[1])\\nfig.tight_layout()\\nshow()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"<\\/a>\\nnested dictionaries\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# list of dictionaries:\\n\\nFoodList = [foods, {'meats':'beef', 'fruit':'banana', 'vegetables':'broccoli'}]\\nprint(FoodList[0])\\nprint(FoodList[1])\\n\\n# dictionary of dictionaries (sometimes called \\\"nested dictionary\\\"):\\n# note: this is an example only. In real world, sinde FoodList is inclusive of foods, you probably would not include both\\n# uniform structures (same number of levels across all elements) is also advisable if possible\\n\\nnestedDict = { 'heroes':super_heroes, 'foods': foods, 'complex_foods':FoodList } \\nprint(nestedDict['heroes'])\\nprint('-'*72)\\nprint(nestedDict['complex_foods'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Accediendo a los datos\\nColumnas\\nTenemos dos formas de acceder a las columnas: por nombre o por atributo (si no contienen espacios ni caracteres especiales).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Accediendo como clave\\n\\n# Accediendo como atributo\\n\\n# Accediendo a varias columnas a la vez\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#run this cell once\\na = 5\\n\\n#run this cell several times\\na = a + 1\\nprint(a)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n \\n<\\/a> Notebooks remember, but not the way you might think\\nThe notebook visible in the browser is not really the notebook, it is only a rendering of the notebook. The actual notebook and its data resides in the IPython kernel. The browser is connected to the kernel via a zmq channel, for the purpose of rendering and input. You can close all the browser windows, but the code and data still resides in the kernel process. As long as the kernel is running you can open a new browser window at 127.0.0.1:8888 and the notebook will be displayed.\\nThe results (including graphs and images) from previous runs are recorded in the notebook, so when it is rendered the previously stored results are shown. The previous results are overwritten only if the cell is executed again.\\nMost important, the results from a previous cell execution remains in the kernel, even if the cell is removed or moved up in the notebook. It happens from time to time that you execute a cell in a given location, creating some data in the kernel. The next cell uses this information in a calculation. So far, so good. Now you decide to re-organise the notebook and move the 'next cell' to a position earlier in the notebook, even before the cell that created the information in the first place. The newly moved cell still works in its new location, because the information is still in memory. At the end of work, you save and close the notebook and exit the kernel.\\nTomorrow you start a new kernel and load the notebook. To ensure that all is fresh and well, you decide to execute all cells in the notebook. But now the moved cell does not work, because its input information is not yet created - it is only created a few cells into the future. Yet it did work yesterday (because of results still remained in memory after moving the cell). But today it fails because there is no memory of something that is yet to come.\\nIt is important to understand that the concept of the non-existence of data prior to...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Camilo\\/.ipynb_checkpoints\\/Taller 3 y 4-checkpoint.ipynb\\\".\\nThe first task is:\\n2.2. Evaluation of the linear regression\\nCan you write Python code for it?\\n\",\"targets\":\"\\nlm1.summary()\\n\\n# This method from STATMODELS sumarize all the results of the regression\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"All features were already normalized to 0~1 except species which is the\\nlabel. We will build a classification model which predicts the species of\\npenguins.\\nBigQueryExampleGen requires a query to specify which data to fetch. Because\\nwe will use all the fields of all rows in the table, the query is quite simple.\\nYou can also specify field names and add WHERE conditions as needed according\\nto the\\nBigQuery Standard SQL syntax.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nQUERY = \\\"SELECT * FROM `tfx-oss-public.palmer_penguins.palmer_penguins`\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# perform forward chaining on the belief that 'switch is flipped'\\nbelief_1, triggered_rules_1 = forward_chain({'switch is flipped'}, rules_1)\\n\\n# print which rules were triggered\\nprint_rules(triggered_rules_1)\\n\\n# show the final belief\\nbelief_1\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIf you now observed switch is flipped but nothing else, what would the above production system lead you to conclude? Use your forward_chain function to find out:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Combine the GDP_growth series and the combo_JPN dataframe together.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncombo_JPN = pd.concat([combo_JPN, GDP_growth], axis=1, join_axes=[combo_JPN.index])\\n\\ncombo_JPN = combo_JPN.rename(columns={0: 'GDP_growth'})\\ncombo_JPN = combo_JPN.set_index('Year')\\ncombo_JPN.tail()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Python 복습\\/14일차.금_pandas + SQL_2\\/14일차_4T_Pandas로 배우는 SQL 시작하기 (4) - HAVING, SUB QUERY.ipynb\\\".\\nThe first task is:\\n영화를 흥행시킨 ( 매출이 많이 발생한 ) 배우 상위 10명\\nrental, payment ...\\n\\nactor_df => actor_id, first_name, last_name\\nfilm_actor_df => actor_id, film_id\\ninventory_df => inventory_id, film_id\\nrental_df => rental_id, inventory_id\\npayment_df => rental_id, amount\\nCan you write Python code for it?\\n\",\"targets\":\"\\nSQL_QUERY = \\\"\\\"\\\"\\n SELECT a.first_name, a.last_name, SUM(p.amount) \\\"revenue\\\"\\n FROM\\n actor a,\\n film_actor fa,\\n inventory i,\\n rental r,\\n payment p\\n WHERE\\n a.actor_id = fa.actor_id\\n AND fa.film_id = i.film_id\\n AND i.inventory_id = r.inventory_id\\n AND r.rental_id = p.rental_id\\n GROUP BY a.actor_id\\n ORDER BY revenue DESC\\n ;\\n\\\"\\\"\\\"\\npd.read_sql(SQL_QUERY, db)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"1) What is the average synapse density per voxel? How does it compare to average and min\\/max synapse density per bin?\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntotal_unmasked = np.sum(data_thresholded[:, 3])\\ntotal_syn = np.sum(data_thresholded[:, 4])\\nprint \\\"avg density per voxel: \\\", total_syn\\/total_unmasked\\na = np.apply_along_axis(lambda x:x[4]\\/x[3], 1, data_thresholded)\\nprint \\\"average per bin: \\\", np.average(a), \\\", std dev: \\\", np.std(a)\\nprint \\\"max\\/min bin density: \\\", np.max(a), \\\", \\\", np.min(a)\\nprint np.sum(a)\\nhist_n, bins, _ = plt.hist(a, 5000)\\nplt.xlim(-.0001, .0035)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Client and Server Together\\nThe client and server should be run in separate terminal windows, so they can communicate with each other. The server output shows the incoming connection and data, as well as the response sent back to the client.\\nEasy Client Coonnections\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# %load socket_echo_client_easy.py\\n\\nimport socket\\nimport sys\\n\\n\\ndef get_constants(prefix):\\n \\\"\\\"\\\"Create a dictionary mapping socket module\\n constants to their names.\\n \\\"\\\"\\\"\\n return {\\n getattr(socket, n): n\\n for n in dir(socket)\\n if n.startswith(prefix)\\n }\\n\\n\\nfamilies = get_constants('AF_')\\ntypes = get_constants('SOCK_')\\nprotocols = get_constants('IPPROTO_')\\n\\n# Create a TCP\\/IP socket\\nsock = socket.create_connection(('localhost', 10000))\\n\\nprint('Family :', families[sock.family])\\nprint('Type :', types[sock.type])\\nprint('Protocol:', protocols[sock.proto])\\nprint()\\n\\ntry:\\n\\n # Send data\\n message = b'This is the message. It will be repeated.'\\n print('sending {!r}'.format(message))\\n sock.sendall(message)\\n\\n amount_received = 0\\n amount_expected = len(message)\\n\\n while amount_received < amount_expected:\\n data = sock.recv(16)\\n amount_received += len(data)\\n print('received {!r}'.format(data))\\n\\nfinally:\\n print('closing socket')\\n sock.close()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Because we restricted our search to papers in an open-access journal, you can then follow their DOIs to freely access their PDFs at the journal's website.\\nWe will now issue calls to Entrez.elink() using these PubMed IDs, to retrieve the IDs of papers that cite them.\\nThe database from which the IDs will be retrieved is PubMed Central, a free digital database of full-text scientific literature in the biomedical and life sciences.\\nA complete list of the kinds of links you can retrieve with Entrez.elink() can be found here.\\n\",\"targets\":\"CA_citing = {\\n id : Entrez.read( Entrez.elink(\\n cmd = \\\"neighbor\\\", # ELink command mode: \\\"neighbor\\\", returns\\n # a set of UIDs in `db` linked to the input UIDs in `dbfrom`.\\n dbfrom = \\\"pubmed\\\", # Database containing the input UIDs: PubMed\\n db = \\\"pmc\\\", # Database from which to retrieve UIDs: PubMed Central\\n LinkName = \\\"pubmed_pmc_refs\\\", # Name of the Entrez link to retrieve: \\\"pubmed_pmc_refs\\\", gets\\n # \\\"Full-text articles in the PubMed Central Database that cite the current articles\\\"\\n from_uid = id # input UIDs\\n ) )\\n for id in CA_ids\\n }\\n\\nCA_citing['22511852']\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Calculate mean square error and the symetric mean absolute percentage error.\\n\",\"targets\":\"mse, smape = ts_pipeline.evaluate(tsdata_test, metrics=[\\\"mse\\\", \\\"smape\\\"])\\nprint(\\\"Evaluate: the mean square error is\\\", mse)\\nprint(\\\"Evaluate: the smape value is\\\", smape)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Clearly now the results are very good. You might ask if we have too few or too many basis functions? First, let's look at the influence coefficients and what is going on.\\n\",\"targets\":\"from pymks.tools import draw_coeff\\n\\n\\ncoeff = model.coef_\\ndraw_coeff(np.real(coeff[:,center, :, :]), figsize=(4, 5))\\n\\n\\ndraw_coeff(np.imag(coeff[:,center, :, :]), figsize=(4, 5))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Create variables to hold features and outcomes separately\\n\\n\\n# Split data into testing and training sets\\n\\n\\n# Create a classifier and fit your features to your outcome\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nBuild a decision tree using all variables\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Bug: typo in variable name (\\\"friut\\\")\\nFix: fix typo\\n\",\"targets\":\"age = \\\"25\\\"\\nname = \\\"Wilfred\\\"\\nintroduction = \\\"Hello, my name is \\\" + name + \\\" and I am \\\" + age + \\\" years old.\\\"\\nprint introduction\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# 1. load the database server\\n\\n# when running from the terminal\\n# python go_server_persistent.py --ts_length 245 --db_name 'stock_prices'\\n\\n# here we load the server as a subprocess for demonstration purposes\\nserver = subprocess.Popen(['python', '..\\/go_server_persistent.py',\\n '--ts_length', str(num_days), '--data_dir', '..\\/db_files', '--db_name', 'stock_prices'])\\ntime.sleep(5) # make sure it loads completely\\n\\n# 2. load the database webserver\\n\\n# when running from the terminal\\n# python go_webserver.py\\n\\n# here we load the server as a subprocess for demonstration purposes\\nwebserver = subprocess.Popen(['python', '..\\/go_webserver.py'])\\ntime.sleep(5) # make sure it loads completely\\n\\n# 3. import the web interface and initialize it\\n\\nfrom webserver import *\\nweb_interface = WebInterface()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nDatabase Initialization\\nLet's start by initializing all the database components.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Case Study Date\\nyear = 1993\\nmonth = 3\\nday = 13\\nhour = 0\\n\\ndt = datetime(year, month, day, hour)\\n\\n# Read NARR Data from THREDDS server\\nbase_url = 'https:\\/\\/www.ncei.noaa.gov\\/thredds\\/catalog\\/narr-a-files\\/'\\n\\n# Programmatically generate the URL to the day of data we want\\ncat = TDSCatalog(f'{base_url}{dt:%Y%m}\\/{dt:%Y%m%d}\\/catalog.xml')\\n\\n# Have Siphon find the appropriate dataset\\nds = cat.datasets.filter_time_nearest(dt)\\n\\n# Download data using the NetCDF Subset Service\\nncss = ds.subset()\\nquery = ncss.query().lonlat_box(north=60, south=18, east=300, west=225)\\nquery.all_times().variables('Geopotential_height_isobaric', 'Temperature_isobaric',\\n 'u-component_of_wind_isobaric',\\n 'v-component_of_wind_isobaric').add_lonlat().accept('netcdf')\\ndata = ncss.get_data(query)\\n\\n# Back up in case of bad internet connection.\\n# Uncomment the following line to read local netCDF file of NARR data\\n# data = Dataset('..\\/..\\/data\\/NARR_19930313_0000.nc','r')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCase Study Data\\nThere are a number of different sites that you can utilize to access past model output analyses and even forecasts. The most robust collection is housed at the National Center for Environmental Information (NCEI, formerly NCDC) on a THREDDS server. The general website to begin your search is\\nhttps:\\/\\/www.ncdc.noaa.gov\\/data-access\\nthis link contains links to many different data sources (some of which we will come back to later in this tutorial). But for now, lets investigate what model output is avaiable\\nhttps:\\/\\/www.ncdc.noaa.gov\\/data-access\\/model-data\\/model-datasets\\nThe gridded model output that are available\\nReanalysis\\n * Climate Forecast System Reanalysis (CFSR)\\n * CFSR provides a global reanalysis (a best estimate of the observed state of the atmosphere) of past weather from January 1979 through March 2011 at a horizontal resolution of 0.5°.\\n * North American Regional Reanalysis (NARR)\\n * NARR is a regional reanalysis of North America containing temperatures, winds, moisture, soil data, and dozens of other parameters at 32km horizontal resolution.\\n * Reanalysis-1 \\/ Reanalysis-2 (R1\\/R2)\\n * Reanalysis-1 \\/ Reanalysis-2 are two global reanalyses of atmospheric data spanning 1948\\/1979 to present at a 2.5° horizontal resolution.\\nNumerical Weather Prediction\\n * Climate Forecast System (CFS) \\n * CFS provides a global reanalysis, a global reforecast of past weather, and an operational, seasonal forecast of weather out to nine months.\\n * Global Data Assimilation System (GDAS)\\n * GDAS is the set of assimilation data, both input and output, in various formats for the Global Forecast System model.\\n * Global Ensemble Forecast System (GEFS)\\n * GEFS is a global-coverage weather forecast model made up of 21 separate forecasts, or ensemble members, used to quantify the amount of uncertainty in a forecast. GEFS produces output four times a day with weather forecasts going out to 16 days.\\n * Global Forecast System (GFS)\\n * The GFS model is a coupled weather forecast model, composed of four...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2015 December 4-6\\nLoading and exploring UTSW RNAi dataset...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndfFile = os.path.join('..', 'data', 'siRNA_dataframe.csv')\\n\\nRNAiDf = pd.read_csv(dfFile, index_col=0)\\n\\nRNAiDf.tail()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.8\\/notebooks\\/auto_examples\\/sampler\\/initial-sampling-method-integer.ipynb\\\".\\nThe first task is:\\nRatio optimized hypercube sampling\\nCan you write Python code for it?\\n\",\"targets\":\"\\nlhs = Lhs(criterion=\\\"ratio\\\", iterations=10000)\\nx = lhs.generate(space.dimensions, n_samples)\\nplot_searchspace(x, 'ratio LHS')\\nprint(\\\"empty fields: %d\\\" % (36 - np.size(np.unique(x, axis=0), 0)))\\npdist_data.append(pdist(x).flatten())\\nx_label.append(\\\"ratio\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"KNN.ipynb\\\".\\nThe first task is:\\n以上方法按键排序\\n\\n程序清单 2-1\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef classify0(inX, dataSet, labels, k):\\n\\tdataSetSize = dataSet.shape[0]\\n\\tdiffMat = tile(inX, (dataSetSize, 1)) - dataSet\\n\\tsqDiffMat = diffMat ** 2\\n\\tsqDistances = sqDiffMat.sum(axis=1)\\n\\tdistances = sqDistances ** 0.5\\n\\tsortedDistIndicies = distances.argsort()\\n\\tclassCount = {}\\n\\tfor i in range(k):\\n\\t\\tvoteIlabel = labels[sortedDistIndicies[i]]\\n\\t\\tclassCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1\\n\\tsortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)\\n\\treturn sortedClassCount[0][0]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"AOI management\\nSome classes that make it a little easier to manage aois and create compact geojson string representations of the aois.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nclass Aoi(CompactFeature):\\n def __init__(self, name, used_by, coordinates, id=None):\\n pg = Polygon(coordinates)\\n prop = {'name': name, 'used by': used_by}\\n if id:\\n prop['id']: id\\n super(CompactFeature, self).__init__(geometry=pg, properties=prop)\\n self[\\\"type\\\"] = 'Feature'\\n\\nclass Aois(CompactFeatureCollection):\\n def __init__(self, features=None, **extras):\\n if features is not None:\\n for f in features:\\n self._check_aoi(f)\\n else:\\n features = []\\n super(CompactFeatureCollection, self).__init__(features, **extras)\\n self.type = 'FeatureCollection'\\n\\n @staticmethod\\n def _check_aoi(aoi):\\n if not isinstance(aoi, Aoi):\\n raise(Exception('expected instance of Aoi, got {}'.format(type(aoi).__name__)))\\n\\n def append(self, aoi):\\n self._check_aoi(aoi)\\n self.features.append(aoi)\\n \\n def write(self, filename):\\n with open(filename, 'w') as dest:\\n dest.write(self.__str__())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Render an episode and save as a GIF file\\n\\nfrom IPython import display as ipythondisplay\\nfrom PIL import Image\\nfrom pyvirtualdisplay import Display\\n\\n\\ndisplay = Display(visible=0, size=(400, 300))\\ndisplay.start()\\n\\n\\ndef render_episode(env: gym.Env, model: tf.keras.Model, max_steps: int): \\n screen = env.render(mode='rgb_array')\\n im = Image.fromarray(screen)\\n\\n images = [im]\\n \\n state = tf.constant(env.reset(), dtype=tf.float32)\\n for i in range(1, max_steps + 1):\\n state = tf.expand_dims(state, 0)\\n action_probs, _ = model(state)\\n action = np.argmax(np.squeeze(action_probs))\\n\\n state, _, done, _ = env.step(action)\\n state = tf.constant(state, dtype=tf.float32)\\n\\n # Render screen every 10 steps\\n if i % 10 == 0:\\n screen = env.render(mode='rgb_array')\\n images.append(Image.fromarray(screen))\\n \\n if done:\\n break\\n \\n return images\\n\\n\\n# Save GIF image\\nimages = render_episode(env, model, max_steps_per_episode)\\nimage_file = 'cartpole-v0.gif'\\n# loop=0: loop forever, duration=1: play each frame for 1ms\\nimages[0].save(\\n image_file, save_all=True, append_images=images[1:], loop=0, duration=1)\\n\\nimport tensorflow_docs.vis.embed as embed\\nembed.embed_file(image_file)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nVisualization\\nAfter training, it would be good to visualize how the model performs in the environment. You can run the cells below to generate a GIF animation of one episode run of the model. Note that additional packages need to be installed for OpenAI Gym to render the environment's images correctly in Colab.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Pull out the number of games in each dyad and plot \\ngames = dfd.games\\n\\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(12, 4))\\n\\naxes[0].hist(games,bins=max(games),histtype = 'stepfilled')\\naxes[0].set_xlabel('Number of interactions')\\naxes[0].set_ylabel('Frequency')\\n\\naxes[1].hist(games,bins=max(games),histtype = 'stepfilled')\\naxes[1].set_yscale('symlog') # symetric log scale NOTE this breaks the nice plotting tools\\naxes[1].set_title(\\\"Log scaled\\\")\\naxes[1].set_xlabel('Number of interactions')\\naxes[1].set_ylabel('Log Frequency')\\n\\n\\nfig.tight_layout()\\n# display_d3()\\n\\nprint \\\"highest number of games in a single dyad = \\\" + str(max(games))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe now have a much more 'normal' dataset, where each data point accounts for a single interaction (i.e. a game) . \\nWhat is the distribution of individual ref-player dyad game numbers?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Build RNN Cell and Initialize\\nStack one or more BasicLSTMCells in a MultiRNNCell.\\n- The Rnn size should be set using rnn_size\\n- Initalize Cell State using the MultiRNNCell's zero_state() function\\n - Apply the name \\\"initial_state\\\" to the initial state using tf.identity()\\nReturn the cell and initial state in the following tuple (Cell, InitialState)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef get_init_cell(batch_size, rnn_size):\\n \\\"\\\"\\\"\\n Create an RNN Cell and initialize it.\\n :param batch_size: Size of batches\\n :param rnn_size: Size of RNNs\\n :return: Tuple (cell, initialize state)\\n \\\"\\\"\\\"\\n # TODO: Implement Function\\n lstm_layers = 2 #Need to pass test?! (otherwise final_state shape will be wrong)\\n lstm = tf.contrib.rnn.BasicLSTMCell(num_units=rnn_size)\\n cell = tf.contrib.rnn.MultiRNNCell([lstm] * lstm_layers)\\n initial_state = cell.zero_state(batch_size, tf.float32)\\n # print(initial_state)\\n initial_state = tf.identity(initial_state, name=\\\"initial_state\\\")\\n return cell, initial_state\\n\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_get_init_cell(get_init_cell)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Creating a TFX pipeline\\nThe pipeline automates the process of preparing item embeddings (in BigQuery), training a Matrix Factorization model (in BQML), and creating and deploying an ANN Service index.\\nThe pipeline has a simple sequential flow. The pipeline accepts a set of runtime parameters that define GCP environment settings and embeddings and index assembly parameters.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport os\\n\\nfrom compute_pmi import compute_pmi\\nfrom create_index import create_index\\nfrom deploy_index import deploy_index\\nfrom export_embeddings import export_embeddings\\nfrom extract_embeddings import extract_embeddings\\nfrom tfx.orchestration.kubeflow.v2 import kubeflow_v2_dag_runner\\n# Only required for local run.\\nfrom tfx.orchestration.metadata import sqlite_metadata_connection_config\\nfrom tfx.orchestration.pipeline import Pipeline\\nfrom train_item_matching import train_item_matching_model\\n\\n\\ndef ann_pipeline(\\n pipeline_name,\\n pipeline_root,\\n metadata_connection_config,\\n project_id,\\n project_number,\\n region,\\n vpc_name,\\n bq_dataset_name,\\n min_item_frequency,\\n max_group_size,\\n dimensions,\\n embeddings_gcs_location,\\n index_display_name,\\n deployed_index_id_prefix,\\n) -> Pipeline:\\n \\\"\\\"\\\"Implements the SCANN training pipeline.\\\"\\\"\\\"\\n\\n pmi_computer = compute_pmi(\\n project_id=project_id,\\n bq_dataset=bq_dataset_name,\\n min_item_frequency=min_item_frequency,\\n max_group_size=max_group_size,\\n )\\n\\n bqml_trainer = train_item_matching_model(\\n project_id=project_id,\\n bq_dataset=bq_dataset_name,\\n item_cooc=pmi_computer.outputs.item_cooc,\\n dimensions=dimensions,\\n )\\n\\n embeddings_extractor = extract_embeddings(\\n project_id=project_id,\\n bq_dataset=bq_dataset_name,\\n bq_model=bqml_trainer.outputs.bq_model,\\n )\\n\\n embeddings_exporter = export_embeddings(\\n project_id=project_id,\\n gcs_location=embeddings_gcs_location,\\n item_embeddings_bq=embeddings_extractor.outputs.item_embeddings,\\n )\\n\\n index_constructor = create_index(\\n project_id=project_id,\\n project_number=project_number,\\n region=region,\\n display_name=index_display_name,\\n dimensions=dimensions,\\n item_embeddings=embeddings_exporter.outputs.item_embeddings_gcs,\\n )\\n\\n index_deployer = deploy_index(\\n project_id=project_id,\\n project_number=project_number,\\n ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2.7.2. Polynomial transformations\\nSimilarly to the previous exercise, now we are interested in obtaining another matrix that will be used to evaluate a polynomial model. In order to do so, compute matrix Z_poly as follows:\\n$$Z_\\\\text{poly} = \\\\left[ \\\\begin{array}{cccc} 1 & x_1^{(1)} & (x_1^{(1)})^2 & (x_1^{(1)})^3 \\\\ 1 & x_1^{(2)} & (x_1^{(2)})^2 & (x_1^{(2)})^3 \\\\ \\\\vdots & \\\\vdots & \\\\vdots \\\\ 1 & x_1^{(8)} & (x_1^{(8)})^2 & (x_1^{(8)})^3 \\\\end{array}\\\\right]$$\\nNote that, in this case, only the first variable of each pattern is used.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Calculate variable Z_poly, using any method that you want\\nZ_poly = np.array(map(lambda x: np.array([x[1]**k for k in range(4)]),X))\\n#Z_poly = \\n\\n\\nTest.assertEqualsHashed(Z_poly,'ba0f38316dffe901b6c7870d13ccceccebd75201','Wrong variable Z_poly')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Again, there is a dense matrix model for $\\\\beta \\\\in {0, 1, 2, 4}$.\\n\",\"targets\":\"jacobi.sample_full_model(size_N=400, size_M1=500, size_M2=600) # M_1, M_2 >= N\\n# jacobi.plot(normalization=True)\\njacobi.hist(normalization=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"5.4.5 'sturges' lag classes\\n\",\"targets\":\"# set the new binning method\\nV.bin_func = 'sturges'\\n\\n# plot\\nfig = V.plot(show=False)\\nprint(f'\\\"{V._bin_func_name}\\\" adjusted {V.n_lags} lag classes - range: {np.round(V.cof[0], 1)} sill: {np.round(V.cof[1], 1)}')\\nfig.update_layout(template='plotly_white')\\niplot(fig)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%bigquery --project $PROJECT\\n\\n# TODO: Your code goes here\\n \\nWITH with_ultrasound AS (\\n SELECT\\n weight_pounds,\\n CAST(is_male AS STRING) AS is_male,\\n IF(mother_age < 18, 'LOW',\\n IF(mother_age > 45, 'HIGH',\\n CAST(mother_age AS STRING))) AS mother_age,\\n CAST(plurality AS STRING) AS plurality,\\n CAST(gestation_weeks AS STRING) AS gestation_weeks,\\n FARM_FINGERPRINT(CONCAT(CAST(YEAR AS STRING), CAST(month AS STRING))) AS hashmonth\\n FROM\\n publicdata.samples.natality\\n WHERE\\n year > 2000\\n AND gestation_weeks > 0\\n AND mother_age > 0\\n AND plurality > 0\\n AND weight_pounds > 0\\n),\\n\\nwithout_ultrasound AS (\\n SELECT\\n weight_pounds,\\n 'Unknown' AS is_male,\\n IF(mother_age < 18, 'LOW',\\n IF(mother_age > 45, 'HIGH',\\n CAST(mother_age AS STRING))) AS mother_age,\\n IF(plurality > 1, 'Multiple', 'Single') AS plurality,\\n CAST(gestation_weeks AS STRING) AS gestation_weeks,\\n FARM_FINGERPRINT(CONCAT(CAST(YEAR AS STRING), CAST(month AS STRING))) AS hashmonth\\n FROM\\n publicdata.samples.natality\\n WHERE\\n year > 2000\\n AND gestation_weeks > 0\\n AND mother_age > 0\\n AND plurality > 0\\n AND weight_pounds > 0\\n),\\n\\npreprocessed AS (\\n SELECT * from with_ultrasound\\n UNION ALL\\n SELECT * from without_ultrasound\\n)\\n\\nSELECT\\n weight_pounds,\\n is_male,\\n mother_age,\\n plurality,\\n gestation_weeks\\nFROM\\n preprocessed\\nWHERE\\n ABS(MOD(hashmonth, 4)) < 3\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreate a new model\\nWith a data set which has been feature engineered, it is ready to create model with the CREATE or REPLACE MODEL statement\\nThis will take 5-10 minutes and will show Done when complete.\\nExercise 4\\nAs in Exercise 1 above, below you are asked to complete the TODO in the cell below to train a linear regression model in BigQuery using weight_pounds as the label. This time, since we're using the supplemented dataset containing without_ultrasound data, name your model babyweight_model_fc. This model will reside within the demo dataset. \\nHave a look at the documentation for CREATE MODEL in BQML to see examples of the correct syntax.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"0.15\\/_downloads\\/plot_3d_to_2d.ipynb\\\".\\nThe first task is:\\nLoad data\\nFirst we'll load a sample ECoG dataset which we'll use for generating\\na 2D snapshot.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmat = loadmat(path_data)\\nch_names = mat['ch_names'].tolist()\\nelec = mat['elec']\\ndig_ch_pos = dict(zip(ch_names, elec))\\nmon = mne.channels.DigMontage(dig_ch_pos=dig_ch_pos)\\ninfo = mne.create_info(ch_names, 1000., 'ecog', montage=mon)\\nprint('Created %s channel positions' % len(ch_names))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Compute multiple distances\\nOf course, to do nearest neighbor regression, we need to compute the distance between our query house and all houses in the training set. \\nTo visualize this nearest-neighbor search, let's first compute the distance from our query house (features_test[0]) to the first 10 houses of the training set (features_train[0:10]) and then search for the nearest neighbor within this small set of houses. Through restricting ourselves to a small set of houses to begin with, we can visually scan the list of 10 distances to verify that our code for finding the nearest neighbor is working.\\nWrite a loop to compute the Euclidean distance from the query house to each of the first 10 houses in the training set.\\n\",\"targets\":\"import sys\\nmax_dis = sys.maxint\\nmax_idx = sys.maxint\\nfor i in xrange(10):\\n d = euclidean_distance(features_test[0], features_train[i])\\n if d < max_dis:\\n max_idx = i\\n max_dis = d\\n print max_idx, max_dis\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"1.4.2 Code Management with Git\\nSee the links from the 2014 Physics 231 website.\\n1.5.4 Fetching and Displaying SDSS Spectra\\nReproduce Figure 1.2 showing a sample SDSS spectrum:\\n\",\"targets\":\"\\\"\\\"\\\"\\nSDSS Spectrum Example\\n---------------------\\nFigure 1.2.\\n\\nAn example of an SDSS spectrum (the specific flux plotted as a function of\\nwavelength) loaded from the SDSS SQL server in real time using Python tools\\nprovided here (this spectrum is uniquely described by SDSS parameters\\nplate=1615, fiber=513, and mjd=53166).\\n\\\"\\\"\\\"\\n# Author: Jake VanderPlas\\n# License: BSD\\n# The figure produced by this code is published in the textbook\\n# \\\"Statistics, Data Mining, and Machine Learning in Astronomy\\\" (2013)\\n# For more information, see http:\\/\\/astroML.github.com\\n# To report a bug or issue, use the following forum:\\n# https:\\/\\/groups.google.com\\/forum\\/#!forum\\/astroml-general\\nfrom matplotlib import pyplot as plt\\nfrom astroML.datasets import fetch_sdss_spectrum\\n\\n#----------------------------------------------------------------------\\n# This function adjusts matplotlib settings for a uniform feel in the textbook.\\n# Note that with usetex=True, fonts are rendered with LaTeX. This may\\n# result in an error if LaTeX is not installed on your system. In that case,\\n# you can set usetex to False.\\nfrom astroML.plotting import setup_text_plots\\nsetup_text_plots(fontsize=8, usetex=True)\\n\\n#------------------------------------------------------------\\n# Fetch single spectrum\\nplate = 1615\\nmjd = 53166\\nfiber = 513\\n\\nspec = fetch_sdss_spectrum(plate, mjd, fiber)\\n\\n#------------------------------------------------------------\\n# Plot the resulting spectrum\\nfig, ax = plt.subplots(figsize=(5, 3.75))\\nax.plot(spec.wavelength(), spec.spectrum, '-k', lw=1)\\n\\nax.set_xlim(3000, 10000)\\nax.set_ylim(25, 300)\\n\\nax.set_xlabel(r'$\\\\lambda {(\\\\rm \\\\AA)}$')\\nax.set_ylabel('Flux')\\nax.set_title('Plate = %(plate)i, MJD = %(mjd)i, Fiber = %(fiber)i' % locals())\\n\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"5. Execute CM To BigQuery IO Synch\\nThis does NOT need to be modified unles you are changing the recipe, click play.\\n\",\"targets\":\"from starthinker.util.project import project\\nfrom starthinker.script.parse import json_set_fields\\n\\nUSER_CREDENTIALS = '\\/content\\/user.json'\\n\\nTASKS = [\\n {\\n 'dataset': {\\n 'auth': 'user',\\n 'dataset': {'field': {'name': 'recipe_slug','kind': 'string','description': 'Place where tables will be created in BigQuery.'}}\\n }\\n },\\n {\\n 'sheets': {\\n 'auth': 'user',\\n 'sheet': 'BB Demo',\\n 'tab': 'Rules',\\n 'range': 'A1:C',\\n 'header': True,\\n 'out': {\\n 'auth': 'user',\\n 'bigquery': {\\n 'dataset': {'field': {'name': 'recipe_slug','kind': 'string','description': 'Place where tables will be created in BigQuery.'}},\\n 'table': 'Rules'\\n }\\n }\\n }\\n },\\n {\\n 'dv360_api': {\\n 'auth': 'user',\\n 'endpoints': [\\n 'advertisers.insertionOrders'\\n ],\\n 'advertisers': {\\n 'single_cell': True,\\n 'values': {'field': {'name': 'dv360_advertisers','kind': 'integer_list','description': 'Comma seperated.'}}\\n },\\n 'out': {\\n 'auth': 'user',\\n 'dataset': {'field': {'name': 'recipe_slug','kind': 'string','description': 'Place where tables will be created in BigQuery.'}}\\n }\\n }\\n },\\n {\\n 'dcm_api': {\\n 'auth': 'user',\\n 'endpoints': [\\n 'campaigns',\\n 'placements',\\n 'placementGroups'\\n ],\\n 'accounts': {\\n 'values': {'field': {'name': 'cm_account','kind': 'integer_list','description': 'Comma seperated.'}}\\n },\\n 'advertisers': {\\n 'values': {'field': {'name': 'cm_advertiser','kind': 'integer_list','description': 'Comma seperated.'}}\\n },\\n 'out': {\\n 'auth': 'user',\\n 'dataset': {'field': {'name': 'recipe_slug','kind': 'string','description': 'Place where tables will be created in BigQuery.'}}\\n }\\n }\\n },\\n {\\n 'bigquery': {\\n 'auth': 'user',\\n 'from': {\\n 'legacy': False,\\n 'parameters': [\\n {'field': {'name': 'dv360_advertiser','kind': 'integer_list','description': 'Comma...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"01-python-intro\\/aula-04\\/Aula 04.ipynb\\\".\\nThe first task is:\\nTambém é possível dar nomes a esses campos:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nstring = '{cidade} é muito bonito(a) durante o(a) {estação}'\\nstring.format(cidade='Bruxelas', estação='Inverno')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"FILTERING CRITERIA<\\/h3>\\n\",\"targets\":\"from shapely.geometry import box, multipoint\\nimport shapely\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"3.Machine_learning\\/2.family_registered_habr.ipynb\\\".\\nThe first task is:\\nГрафик для зависимости, полученной по обучающим данным\\n\\nThe graph for the dependence obtained from the training data\\nCan you write Python code for it?\\n\",\"targets\":\"\\nplt.scatter(X_train, y_train, color='black')\\nplt.plot(X_train, lr.predict(X_train), color='blue',\\n linewidth=3)\\n\\nplt.xlabel('StateRegistrationOfBirth')\\nplt.ylabel('State Registration OfPaternity Examination')\\nplt.title=\\\"Regression on train data\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"18-11-22-Deep-Learning-with-PyTorch\\/02-Introduction to PyTorch\\/Part 1 - Tensors in PyTorch.ipynb\\\".\\nThe first task is:\\nStack them up!\\nThat's how you can calculate the output for a single neuron. The real power of this algorithm happens when you start stacking these individual units into layers and stacks of layers, into a network of neurons. The output of one layer of neurons becomes the input for the next layer. With multiple input units and output units, we now need to express the weights as a matrix.\\n\\nThe first layer shown on the bottom here are the inputs, understandably called the input layer. The middle layer is called the hidden layer, and the final layer (on the right) is the output layer. We can express this network mathematically with matrices again and use matrix multiplication to get linear combinations for each unit in one operation. For example, the hidden layer ($h_1$ and $h_2$ here) can be calculated \\n$$\\n\\\\vec{h} = [h_1 \\\\, h_2] = \\n\\\\begin{bmatrix}\\nx_1 \\\\, x_2 \\\\cdots \\\\, x_n\\n\\\\end{bmatrix}\\n\\\\cdot \\n\\\\begin{bmatrix}\\n w_{11} & w_{12} \\\\\\n w_{21} &w_{22} \\\\\\n \\\\vdots &\\\\vdots \\\\\\n w_{n1} &w_{n2}\\n\\\\end{bmatrix}\\n$$\\nThe output for this small network is found by treating the hidden layer as inputs for the output unit. The network output is expressed simply\\n$$\\ny = f_2 ! \\\\left(\\\\, f_1 ! \\\\left(\\\\vec{x} \\\\, \\\\mathbf{W_1}\\\\right) \\\\mathbf{W_2} \\\\right)\\n$$\\nCan you write Python code for it?\\n\",\"targets\":\"\\n### Generate some data\\ntorch.manual_seed(7) # Set the random seed so things are predictable\\n\\n# Features are 3 random normal variables\\nfeatures = torch.randn((1, 3))\\n\\n# Define the size of each layer in our network\\nn_input = features.shape[1] # Number of input units, must match number of input features\\nn_hidden = 2 # Number of hidden units \\nn_output = 1 # Number of output units\\n\\n# Weights for inputs to hidden layer\\nW1 = torch.randn(n_input, n_hidden)\\n# Weights for hidden layer to output layer\\nW2 = torch.randn(n_hidden, n_output)\\n\\n# and bias terms for hidden and output layers\\nB1 = torch.randn((1, n_hidden))\\nB2 = torch.randn((1, n_output))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"05_bqnotebook\\/exploration.ipynb\\\".\\nThe first task is:\\nInstalling dependencies\\nRegular Python dependencies can be installed using pip\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%pip install pytz\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Copy_of_time_series_visualization.ipynb\\\".\\nThe first task is:\\nReduction to list\\nThe result of the above region reduction function is an ee.FeatureCollection, but a list is easier to work with. The following takes a collection and a list of properties to aggregate into a list of lists.\\n\\nApply the above defined regionReduce function to all images in the passed collection.\\nRemove any features that are null for the requested properties (ensure equal length property lists in the following step)\\nAggregate requested properties into a list of lists\\nExtract the list of lists from the resulting dictionary and then send the data to the Colab VM client with getInfo()\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef getReReList(col, props):\\n dict = col.map(regionReduce) \\\\\\n .filter(ee.Filter.notNull(props)) \\\\\\n .reduceColumns(\\n reducer = ee.Reducer.toList().repeat(len(props)),\\n selectors = props)\\n\\n return(ee.List(dict.get('list')).getInfo())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Project1\\/.ipynb_checkpoints\\/Project 1 - Titanic-checkpoint.ipynb\\\".\\nThe first task is:\\nThe survival rate of the first class passengers was more than 60%, while the survival rate of the third class ones was merely around 25%. So we can see that there was a bias on weathiness and soci-economic statuses, even in life-threatning situations.\\nNow, what if we factor in both passenger classes and types (male, female or children), which would have more weight in survival rate?\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntitanic.groupby(['Pclass', 'Type']).Type.count()\\n\\nsns.set(style=\\\"darkgrid\\\")\\nax = sns.countplot(x = \\\"Pclass\\\", hue = \\\"Type\\\", data = titanic)\\nplt.show()\\n\\ntitanic.groupby(['Pclass', 'Type']).agg({'Survived': 'sum'})\\n\\nsns.set(style=\\\"darkgrid\\\")\\nax = sns.countplot(x = \\\"Pclass\\\", hue = \\\"Type\\\", data = survived)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Como en los libros del Proyecto Gutenberg, aquí también podemos imprimir los nombres de los ficheros. En este caso son poco significativos, nos nos dicen nada del contenido.\\n\",\"targets\":\"# Brown está formado por 500 documentos\\nprint(len(brown.fileids()))\\n# imprimimos solos los 10 primeros\\nprint(brown.fileids()[:10])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"02-python-oo\\/aula-03\\/Aula 03.ipynb\\\".\\nThe first task is:\\nPodemos somar vetores usando o operador +:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nv1 + v2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# casual: all data \\ndf_X_4_casual = df[predictors_4_casual]\\ndf_y_casual_log = df['casual_log']\\n\\n# casual: build once again and finally the model on all data\\nmodel_casual = RandomForestRegressor(n_estimators=120, min_samples_split=10, min_samples_leaf=5)\\nmodel_casual.fit(df_X_4_casual, df_y_casual_log)\\n\\n# registered: all data \\ndf_X_4_registered = df[predictors_4_registered]\\ndf_y_registered_log = df['registered_log']\\n\\n# registered: build once again and finally the model on all data\\nmodel_registered = RandomForestRegressor(n_estimators=90, min_samples_split=10, min_samples_leaf=5)\\nmodel_registered.fit(df_X_4_registered, df_y_registered_log)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFinal model\\nLet us train one last time the type of model that had the best performance (with the optimal settings). This time, we do it on all the data.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"back<\\/a>\\n \\nSave Tagger\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef ensure_dir(path):\\n if not path.exists():\\n path.mkdir()\\n \\nensure_dir(tagger_dir)\\ntrained_tagger.model.dump(str(tagger_dir \\/ 'model'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"04-IntroductionToComputationalRadiometryWithPyradi.ipynb\\\".\\nThe first task is:\\nPlotting of spectral variables\\nThe title appears trivial, but there is a hidden subtlety when working with and plotting radiometric variables. In the section above `spectral variables in pyradi'', the data was created in the wavelength domain (using thelinspace` function), but plotted in both wavelength and wavenumber domains. Note that the data was not resampled to wavenumber domain before plotting: the wavenumber plots are not at constant intervals. The wavelength domain was merely recalculated to wavenumber domain. This is illustrated in the graph below.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nwlc = np.linspace(0.5, 8.5, 17).reshape(-1,1) # wavelength \\nwnc = ryutils.convertSpectralDomain(wlc, type='ln') # wavenumber\\np = ryplot.Plotter(2,1,3,figsize=(18,2))\\nfor i in range(wlc.shape[0]):\\n p.plot(1,np.array([wlc[i],wlc[i]]), np.array([0,1.]), 'Constant wavelength intervals',\\n 'Wavelength $\\\\mu$m', plotCol=['r'], markers=['o'], maxNY=1)\\n p.plot(2,np.array([wnc[i],wnc[i]]), np.array([0,1.]), 'Non-constant wavenumber intervals',\\n 'Wavenumber cm$^{-1}$',plotCol=['r'], markers=['o'], maxNX=5, maxNY=1, pltaxis=[0, 10000, 0, 1]);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Read in first 10 lines of bmi table\\nbmi_sub_first10 = df_bmi.head(10)\\n\\n# Grab the last 10 rows\\nbmi_sub_last10 = df_bmi.tail(10)\\n\\n# Reset the index values so the second dataframe appends properly\\nbmi_sub_last10=bmi_sub_last10.reset_index(drop=True)\\n# drop=True option avoids adding new index column with old index values\\n\\nbmi_sub_first10\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTake note that the read_csv method we used can take some additional options. Many functions in python have a set of options that\\ncan be set by the user if needed.\\nMore about all of the read_csv options here.\\nConcatenating DataFrames\\nWe can use the concat function in Pandas to append either columns or rows from\\none DataFrame to another. Let's grab two subsets of our data to see how this\\nworks.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Caveat:\\nThe cell below is the longest running part of this code because we must interact with excel, individually load 9 sheets, and then concatenate them into a single dataset.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n#################################################################\\n###################### Read EITC data ###########################\\n##parse the EITC data:\\neitc = pd.ExcelFile(\\\"\\/\\\".join([data_path, \\\"EITC Calculator-2-14.xlsx\\\"]))\\nsheets = eitc.sheet_names\\neitc.close()\\n\\neitc_dict = pd.read_excel(\\\"\\/\\\".join([data_path, \\\"EITC Calculator-2-14.xlsx\\\"]), sheetname = sheets[9:17], skiprows = 14 )\\n\\neitc_o = pd.concat(eitc_dict)\\n\\n#################################################################\\n################### Process eitc_o data ###########################\\neitc_o = eitc_o.iloc[:,[0,40]]\\neitc_o.dropna(inplace=True)\\neitc_o = eitc_o.loc[eitc_o[2014]>0,:]\\neitc_o.reset_index(level=0, inplace=True)\\neitc_o.reset_index(drop=True, inplace=True)\\n#eitc_o['num_kids'] = eitc_o.level_0.str.extract(\\\"(\\\\d)\\\", expand=False)\\n#eitc_o['married'] = eitc_o.level_0.str.contains(\\\"Married\\\").astype(int)\\n\\n#eitc_o.to_csv(\\\".\\/EITC_benefits.csv\\\")\\n\\n#################################################################\\n################# Read & process fmr data ######################\\n#read in fmr data\\nfmr_o1 = pd.read_excel(\\\"\\/\\\".join([data_path, \\\"FY2014_4050_RevFinal.xls\\\"]))\\n\\n#drop non Metro areas:\\nfmr_o1 = fmr_o1[fmr_o1.Metro_code.str.contains(\\\"METRO\\\")]\\n\\n#extract cbsa code:\\nfmr_o1['cbsa'] = fmr_o1.Metro_code.str.extract(\\\"RO(\\\\d{4,5})[MN]\\\", expand=False)\\n\\n#edit FMR CBSA codes to match tax CBSA codes:\\ncbsa_chng_map = {'14060':'14010', '29140':'29200', '31100':'31080', '42060':'42200', '44600':'48260'}#, '36061':'35620'}\\nfmr_o1.cbsa.replace(cbsa_chng_map, inplace=True)\\n\\n#fetch columns that pertain to FMR figures\\nfmr_cols = fmr_o1.columns[fmr_o1.columns.str.contains(\\\"fmr\\\\d\\\")]\\n\\n#clean up the area names by removing \\\"MSA and HUD Metro FMR Area\\\"\\nfmr_o1['Areaname'] = fmr_o1.Areaname.apply(lambda x: re.sub(\\\" MSA| HUD Metro FMR Area\\\", \\\"\\\", x))\\n\\n#drop duplicates based on cbsa code:\\n#fmr_o = fmr_o.drop_duplicates('cbsa')\\nfmr_o2 = fmr_o1.groupby(\\\"cbsa\\\").mean()[fmr_cols]\\nfmr_o = pd.concat([fmr_o2, fmr_o1[['cbsa',...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"1d. Comparing analytic and numerical results of conditional distributions\\nNow we would like to get a conditional distribution: given some value of $x$ (or $y$), what is the probability distribution for $y$ (or $x$)? In our example, this is most straightforward if we condition on a grid value. Otherwise, we would probably do some interpolation. Here we choose a couple particular values for fixing; feel free to play around with them.\\n\",\"targets\":\"xi = 30 # index into the grid of x's\\nfixed_x = xvalues[xi]\\nprint(fixed_x)\\nyi = 40 # similarly for y\\nfixed_y = yvalues[yi]\\nprint(fixed_y)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And run the pipeline\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nlg.run(['RunLDA', '--workers', '1', '--local-scheduler', '--datadir', datadir, '--prefixes', prefixes_json])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#! skip\\n{ key: type(value) for key, value in testsystem.__dict__.items()}\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLet's have a look at the content\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Beautiful!\\nSo, to end this section, just two remarks:\\n\\nWe have understood that if the framework is supported, the starting point is to combine the generic backend for the framework (PlotlyBackend) with the template backend of the specific plot (BandsBackend). Afterwards, we may have to tweak things a little.\\nKnowing how the generic framework backend works helps to make your code simpler. E.g. if you check PlotlyBackend.__doc__, you will find that we could have easily included some defaults for the axes titles.\\n\\nCreating a backend for a non supported framework\\nArmed with our knowledge from the previous sections, we face the most difficult of the challenges: there's not even a generic backend for the framework that we want to use.\\nWhat we have to do is quite clear, develop our own generic backend. But how? Let's go to the Backend class for help:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sisl.viz.backends.templates import Backend\\n\\nprint(Backend.__doc__)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"And we see that this correction operator successfully corrects the cumulative total noise:\\n\",\"targets\":\"(noise_total + correction) % 2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"2.3.3 重みとバイアスによる実装\\n以下では-θをバイアスbと命名した。\\n文脈によっては重みもバイアスも含めてパラメータを「重み」と呼ぶ場合がある。\\n\",\"targets\":\"# ANDゲートを実装\\ndef AND(x1, x2):\\n x = np.array([x1, x2])\\n w = np.array([0.5, 0.5])\\n b = -0.7\\n tmp = np.sum(w*x) + b\\n if tmp <= 0:\\n return 0\\n else:\\n return 1\\n\\n# NANDゲートを実装\\ndef NAND(x1, x2):\\n x = np.array([x1, x2])\\n w = np.array([-0.5, -0.5]) # 重みとバイアスだけがANDと違う\\n b = 0.7\\n tmp = np.sum(w*x) + b\\n if tmp <= 0:\\n return 0\\n else:\\n return 1\\n\\n# ORゲートを実装\\ndef OR(x1, x2):\\n x = np.array([x1, x2])\\n w = np.array([0.5, 0.5]) # 重みとバイアスだけがANDと違う\\n b = -0.2\\n tmp = np.sum(w*x) + b\\n if tmp <= 0:\\n return 0\\n else:\\n return 1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"!gvim draggable_1.html\\n\\nHTML('.\\/draggable_1.html')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSupporting Technologies\\n\\njQuery\\n\\nExamples\\nDraggable Elements\\n\\nhttps:\\/\\/www.w3schools.com\\/tags\\/att_global_draggable.asp\\nhttps:\\/\\/www.w3schools.com\\/tags\\/tryit.asp?filename=tryhtml5_global_draggable\\nhttps:\\/\\/www.w3schools.com\\/html\\/html5_draganddrop.asp\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"03-NLP\\/helloworld-nlp.ipynb\\\".\\nThe first task is:\\nLet's process a text file\\nPython makes working with files pretty simple. \\nLet's use one of the books from the Project Gutenberg, which I have already dowloaded from ....\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfilePath = \\\"..\\/datasets\\/theprince.txt\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Module-03g-Model-HyperParameterOpt.ipynb\\\".\\nThe first task is:\\nBasic checks\\nCheck if the columns are the same in train and test.\\nWhat else will you check? [Discuss]\\nCan you write Python code for it?\\n\",\"targets\":\"\\nX_train.columns\\n\\nX_test.columns\\n\\nprint(X_train.shape, X_test.shape)\\n\\nprint(\\\"train\\\")\\nprint(X_train.dtypes)\\nprint()\\nprint(\\\"test\\\")\\nprint(X_test.dtypes)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Clean up field values\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef sanitize(t, i, fname, value):\\n if fname == '_id': return value\\n (ftype, fmult) = allFields[t][fname]\\n newValue = []\\n for v_raw in value:\\n if v_raw == None or v_raw in NULL_VALUES: continue\\n elif ftype == 'text': v = v_raw\\n elif ftype == 'bool': v = bools(v_raw, i, t, fname)\\n elif ftype == 'number': v = num(v_raw, i, t, fname)\\n elif ftype == 'decimal': v = decimal(v_raw, i, t, fname)\\n elif ftype == 'email': v = email(v_raw, i, t, fname)\\n elif ftype == 'valuta': v = money(v_raw, i, t, fname)\\n elif ftype == 'date': v = dt(v_raw, i, t, fname)\\n elif ftype == 'datetime': v = dtm(v_raw, i, t, fname)\\n else: v = v_raw\\n if v != None and (fmult <= 1 or v != ''): newValue.append(v)\\n if len(newValue) == 0:\\n defValue = DEFAULT_VALUES.get(t, {}).get(fname, None)\\n if defValue != None:\\n newValue = [defValue]\\n return newValue\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Building the model\\nWe use a model where the localization network is a two layer convolution network which operates directly on the image input. The output from the localization network is a 6 dimensional vector specifying the parameters in the affine transformation. \\nThe localization feeds into the transformer layer which applies the transformation to the image input. In our setup the transformer layer downsamples the input by a factor 3. \\nFinally a 2 layer convolution layer and 2 fully connected layers calculates the output probabilities. \\nThe model\\nInput -> localization_network -> TransformerLayer -> output_network -> predictions\\n | |\\n >--------------------------------^\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef build_model(input_width, input_height, output_dim,\\n batch_size=BATCH_SIZE):\\n ini = lasagne.init.HeUniform()\\n l_in = lasagne.layers.InputLayer(shape=(None, 1, input_width, input_height),)\\n\\n # Localization network\\n b = np.zeros((2, 3), dtype='float32')\\n b[0, 0] = 1\\n b[1, 1] = 1\\n b = b.flatten()\\n loc_l1 = pool(l_in, pool_size=(2, 2))\\n loc_l2 = conv(\\n loc_l1, num_filters=20, filter_size=(5, 5), W=ini)\\n loc_l3 = pool(loc_l2, pool_size=(2, 2))\\n loc_l4 = conv(loc_l3, num_filters=20, filter_size=(5, 5), W=ini)\\n loc_l5 = lasagne.layers.DenseLayer(\\n loc_l4, num_units=50, W=lasagne.init.HeUniform('relu'))\\n loc_out = lasagne.layers.DenseLayer(\\n loc_l5, num_units=6, b=b, W=lasagne.init.Constant(0.0), \\n nonlinearity=lasagne.nonlinearities.identity)\\n \\n # Transformer network\\n l_trans1 = lasagne.layers.TransformerLayer(l_in, loc_out, downsample_factor=3.0)\\n print \\\"Transformer network output shape: \\\", l_trans1.output_shape\\n \\n # Classification network\\n class_l1 = conv(\\n l_trans1,\\n num_filters=32,\\n filter_size=(3, 3),\\n nonlinearity=lasagne.nonlinearities.rectify,\\n W=ini,\\n )\\n class_l2 = pool(class_l1, pool_size=(2, 2))\\n class_l3 = conv(\\n class_l2,\\n num_filters=32,\\n filter_size=(3, 3),\\n nonlinearity=lasagne.nonlinearities.rectify,\\n W=ini,\\n )\\n class_l4 = pool(class_l3, pool_size=(2, 2))\\n class_l5 = lasagne.layers.DenseLayer(\\n class_l4,\\n num_units=256,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n W=ini,\\n )\\n\\n l_out = lasagne.layers.DenseLayer(\\n class_l5,\\n num_units=output_dim,\\n nonlinearity=lasagne.nonlinearities.softmax,\\n W=ini,\\n )\\n\\n return l_out, l_trans1\\n\\nmodel, l_transform = build_model(DIM, DIM, NUM_CLASSES)\\nmodel_params = lasagne.layers.get_all_params(model, trainable=True)\\n\\nX = T.tensor4()\\ny = T.ivector()\\n\\n# training output\\noutput_train =...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# Extracting \\\"Twist\\\" of 22nd bp\\ntwist_20bp = pdna.data['bps']['22']['twist']\\n\\n#Twist vs Time for 22nd bp\\nplt.title('22nd bp')\\nplt.plot(pdna.time, twist_20bp)\\nplt.xlabel('Time (ps)')\\nplt.ylabel('Twist ( $^o$)')\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLocal base-step parameter of a base-pair directly from dictionary\\n\\nThe DNA.data is a python dictionary which contains all the data as a Python Dictionary. For a base-step, parameter as a function of time can be directly extracted.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# This function uses the Doppler equivalency between wavelength and velocity\\nimport astropy.units as u\\ndef wave2doppler(w, w0):\\n w0_equiv = u.doppler_optical(w0)\\n w_equiv = w.to(u.km\\/u.s, equivalencies=w0_equiv)\\n return w_equiv\\n\\nprint(wave2doppler(waveclosetoHa, 656.489 * u.nm).to(u.km\\/u.s))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe get -132, -86 and +5 km\\/s.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"(b) Solve the high-dimensional problem with OLS (1 pt)\\n(Note that the feature matrix x is transposed here as compared to problem 3.)\\nIf you do this right, the training error should be way better than the minimum possible. That is truly incredible. Unbelievable. Literally. And the validation error is much worse than what you would get from just guessing that $\\\\beta=0$. Explain why below.\\n\",\"targets\":\"beta_ols = ## YOUR CODE HERE ##\\n\\ny_hat = ## YOUR CODE HERE ##\\ny_val_hat = ## YOUR CODE HERE ##\\n\\nprint('Training MSE:', mean_squared_error(y, y_hat))\\n\\nprint('Validation MSE:', mean_squared_error(y_val, y_val_hat))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"2.10 Basic loops\\nPython uses for and while loops to repeat sections of statements. A for loop runs for a set number of times, whereas a while loop repeats a statement until a certain condition is met. The statements to be repeated must be indented for the interpreter to recognise them as such.\\nThe example below demonstrates how to do the following:\\n- Cycle through the generated list and:\\n - Print the current element in the list; and\\n - Print Xs, which are repeated per element.\\n- Exit the loop and print a line that is not repeated.\\n\",\"targets\":\"# An example of a loop that uses the \\\"for\\\" construct.\\n\\n# You can specify the list manually or use a variable containing the list as input.\\n# The syntax for manual input is: `for item in [1, 2, 3]:`\\n\\nfor item in myrange:\\n print(item)\\n print(item * 'X')\\nprint('End of loop (not included in the loop)')\\n\\n# An example of a loop that uses the \\\"while\\\" construct.\\n\\n# Firstly, set a counter variable to check whether the end of the list has been reached.\\n\\ni = 0\\nwhile i < len(myrange):\\n print(myrange[i])\\n print(myrange[i] * 'X')\\n i = i + 1\\nprint('End of loop (not included in the loop)')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"03-adult-income-by-census.ipynb\\\".\\nThe first task is:\\nAbove plot shows percentage of population with respect to education and income, and it seems people with Masters and PhD tend to earn to more (more number of people are in >50K bucket).\\nIntuition 2:\\nPeople earn more as they get more experience.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntrain.groupby('income').hist(figsize=(15,12))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And the opposite is also possible with to_linear.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nstep.to_linear()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"# 10 fold cross validation\\ndt_seeds_cv = tree.DecisionTreeClassifier()\\ndt_seeds_cv = dt_seeds_cv.fit(x,y) #fit the model on all data\\n\\nscores = cross_validation.cross_val_score(dt_seeds_cv,x,y,cv=10)\\n\\nscores.mean()\\n\\ndt_seeds_cv.feature_importances_\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAlthough the precision and recall for class 3 have improved, there's still a problem in having the model distinguish between classes 1 and 3\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"05_categorizing_and_tagging_words.ipynb\\\".\\nThe first task is:\\nnot all corpora have the same tag sets, so can force mapping to universal tagset\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnltk.corpus.brown.tagged_words(tagset='universal')\\n\\nnltk.corpus.treebank.tagged_words(tagset='universal')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"2.4 Summarize effects of accouning for uncertainties in equil. constants & total boron\\nFractional increase in propagated uncertainty due to accounting for uncertainties from equilibrium constants (default values)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%%octave\\n printf(\\\"%s %s %s %s %s %s %s %s %s \\\\n\\\", ekbhead{1:9});\\n %printf(\\\"%f %f %f %f %f %f %f %f %f \\\\n\\\", e(1:9));\\n %printf(\\\"%f %f %f %f %f %f %f %f %f \\\\n\\\", ek(1:9));\\n printf(\\\"%f %f %f %f %f %f %f %f %f \\\\n\\\", ek(1:9) .\\/ e(1:9));\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"CSS Hierarchies\\nThe examples have shown that when CSS styles overlap, the one that comes last in the HTML render, takes precedence. So the following yield different results:\\n\",\"targets\":\"df4 = pd.DataFrame([['text']])\\ndf4.style.applymap(lambda x: 'color:green;')\\\\\\n .applymap(lambda x: 'color:red;')\\n\\ndf4.style.applymap(lambda x: 'color:red;')\\\\\\n .applymap(lambda x: 'color:green;')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"#batch_size = 1\\n#batch_size = 4\\nbatch_size = 64\\n\\nbatches = vgg.get_batches(path+'train', batch_size=batch_size)\\nval_batches = vgg.get_batches(path+'valid', batch_size=batch_size)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n(Note that, other than creating the Vgg16 object, none of these steps are necessary to build a model; they are just showing how to use the class to view imagenet predictions.)\\nUse our Vgg16 class to finetune a Dogs vs Cats model\\nTo change our model so that it outputs \\\"cat\\\" vs \\\"dog\\\", instead of one of 1,000 very specific categories, we need to use a process called \\\"finetuning\\\". Finetuning looks from the outside to be identical to normal machine learning training - we provide a training set with data and labels to learn from, and a validation set to test against. The model learns a set of parameters based on the data provided.\\nHowever, the difference is that we start with a model that is already trained to solve a similar problem. The idea is that many of the parameters should be very similar, or the same, between the existing model, and the model we wish to create. Therefore, we only select a subset of parameters to train, and leave the rest untouched. This happens automatically when we call fit() after calling finetune().\\nWe create our batches just like before, and making the validation set available as well. A 'batch' (or mini-batch as it is commonly known) is simply a subset of the training data - we use a subset at a time when training or predicting, in order to speed up training, and to avoid running out of memory.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Creating numpy arrays\\nYou can create an array from scratch, similar to how you might create a list \\/ tuple \\/ whatever:\\n\",\"targets\":\"a = np.array((1,2,3)) # or np.array((1,2,3))\\nprint a\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Lectures\\/Lecture_2\\/Jupyter_notebook_sheets\\/random_module.ipynb\\\".\\nThe first task is:\\nGiven $\\\\lambda>0$ and $\\\\kappa>0$, the density function of the Weibull distribution of parameters $\\\\lambda$ and $\\\\kappa$, defined over $[0,\\\\infty)$, is equal to $\\\\frac{\\\\kappa}{\\\\lambda}(\\\\frac{x}{\\\\lambda})^{k-1}e^{-(\\\\frac{x}{\\\\lambda})^\\\\kappa}$. It is illustrated with $\\\\lambda=1$ and $\\\\kappa=1.5$.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%matplotlib inline\\nfrom matplotlib.pyplot import hist, gca\\nfrom matplotlib.ticker import FuncFormatter\\n\\nfrom random import weibullvariate\\n\\nnb_of_values = 100000\\ngenerated_values = []\\nfor i in range(nb_of_values):\\n generated_values.append(weibullvariate(1, 1.5))\\n \\ndef to_percent(x, _):\\n return str(x \\/ nb_of_values * 100) + '%'\\n\\ngca().yaxis.set_major_formatter(FuncFormatter(to_percent))\\nhist(generated_values, 50)\\nprint()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%env TFLITE_FILE=example.tflite\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCompile a model for the Edge TPU\\nThis notebook offers a convenient way to compile a TensorFlow Lite model for the Edge TPU, in case you don't have a system that's compatible with the Edge TPU Compiler (Debian Linux only).\\nSimply upload a compatible .tflite file to this Colab session, run the code below, and then download the compiled model.\\nFor more details about how to create a model that's compatible with the Edge TPU, see the documentation at coral.ai.\\n<\\/a>\\n \\n<\\/a>\\nUpload a compatible TF Lite model\\nTo use this script, you need to upload a TensorFlow Lite model that's fully quantized and meets all the Edge TPU model requirements.\\nWith a compatible model in-hand, you can upload it as follows:\\n\\nClick the Files tab (the folder icon) in the left panel. (Do not change directories.)\\nClick Upload to session storage (the file icon). \\n\\nFollow your system UI to select and open your .tflite file.\\nWhen it's uploaded, you should see the file appear in the left panel.\\n4. Replace example.tflite with your uploaded model's filename:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"MeetupPrez.ipynb\\\".\\nThe first task is:\\nScaling test file\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf = pd.read_csv('test_extended.csv')\\ndf['CompetitionDistanceLog'] = df.CompetitionDistance.apply(np.log1p)\\ndf.CompetitionOpen = df.CompetitionOpen + 31\\ndf['CompetitionOpenLog'] = df.CompetitionOpen.apply(np.log1p)\\ndf.EurUsdRate = df.EurUsdRate - 0.7\\ndf.DaysLeft = df.DaysLeft.astype(int)\\ndf.DaysAfter = df.DaysAfter.astype(int)\\ndf.CompetitionOpenNull = df.CompetitionOpenNull + 31\\ndf['CompetitionOpenNullLog'] = df.CompetitionOpenNull.apply(np.log1p)\\n\\n\\nnew = df\\n\\na = new['CompetitionDistance']\\nd = new['CompetitionOpen']\\ne = new['PromoOpen']\\nf = new['CompetitionOpenNull']\\ng = new['CompetitionDistanceLog']\\nh = new['CompetitionOpenLog']\\ni = new['CompetitionOpenNullLog']\\n\\na_scaled = featureScaling(a)\\nd_scaled = featureScaling(d)\\ne_scaled = featureScaling(e)\\nf_scaled = featureScaling(f)\\ng_scaled = featureScaling(g)\\nh_scaled = featureScaling(h)\\ni_scaled = featureScaling(i)\\n\\nnew['CompetitionDistance'] = a_scaled\\nnew['CompetitionOpen'] = d_scaled\\nnew['PromoOpen'] = e_scaled\\nnew['CompetitionOpenNull'] = f_scaled\\nnew['CompetitionDistanceLog'] = g_scaled\\nnew['CompetitionOpenLog'] = h_scaled\\nnew['CompetitionOpenNullLog'] = i_scaled\\n\\nnew.to_csv('scaled_test.csv', na_rep='0', header=True, index = False)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Create dataframe\\n\",\"targets\":\"raw_data = {'first_name': ['Jason', 'Molly', 'Tina', 'Jake', 'Amy'], \\n 'last_name': ['Miller', 'Jacobson', 'Ali', 'Milner', 'Cooze'], \\n 'female': [0, 1, 1, 0, 1],\\n 'age': [42, 52, 36, 24, 73], \\n 'preTestScore': [4, 24, 31, 2, 3],\\n 'postTestScore': [25, 94, 57, 62, 70]}\\ndf = pd.DataFrame(raw_data, columns = ['first_name', 'last_name', 'age', 'female', 'preTestScore', 'postTestScore'])\\ndf\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Correlation heatmap\\n\",\"targets\":\"import seaborn as sns # conventional alias\\n#sns.set(style=\\\"white\\\")\\n\\n# Compute the correlation matrix\\ncorr = df.corr()\\n\\n# Generate a mask for the upper triangle\\nmask = np.zeros_like(corr, dtype=np.bool)\\nmask[np.triu_indices_from(mask)] = True\\n\\n# Set up the matplotlib figure\\nf, ax = plt.subplots(figsize=(11, 9))\\n\\n# Generate a custom diverging colormap\\n#cmap = sns.diverging_palette(220, 10, as_cmap=True)\\n\\n# By using heatmap twice we get bold all correlations above 0.6\\nsns.heatmap(corr, mask=mask, annot=True)\\nsns.heatmap(corr, mask= abs(corr) < 0.6, cbar=False, annot=True)\\n #annot_kws={\\\"weight\\\": \\\"bold\\\"})\\n# Draw the heatmap with the mask and correct aspect ratio\\n#sns.heatmap(corr, cmap=cmap, vmax=.3,\\n# square=True, xticklabels=5, yticklabels=5,\\n# linewidths=.5, cbar_kws={\\\"shrink\\\": .5}, ax=ax)\\n\\n# Want to look further on correlation between RM, LSTAT and house price (MEDV)\\nsns.jointplot(df['RM'], df['target'])\\nsns.jointplot(df['LSTAT'], df['target'])\\n\\n# Which of the features exhibit a linear correlation with the target?\\ncorr.iloc[-1].apply(abs).sort_values(ascending=True)\\n\\n#X = df[['RM', 'LSTAT']]\\nX = df[['LSTAT']]\\ny = df['target']\\nX.boxplot()\\n\\nfrom sklearn.linear_model import LinearRegression\\nfrom sklearn.model_selection import train_test_split\\n\\n# Split data into (80%) training and (20%) test data\\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\\n\\n# Assuming a linear relationship between number of Rooms and House price\\nmodel = LinearRegression()\\n\\n# Train model\\nmodel.fit(X_train, y_train)\\n\\ndef show_results(model, X_test, y_test):\\n # Predict y-values from model:\\n y_pred = model.predict(X_test)\\n # The coefficients\\n #print('Coefficients: \\\\n', model.coef_)\\n # The mean squared error\\n print(\\\"Mean squared error: %.2f\\\" % np.mean((y_pred - y_test) ** 2))\\n # Explained variance score: 1 is perfect prediction\\n print('Variance score: %.2f' % model.score(X_test, y_test))\\n # Discarding higher order terms\\n if X_test.shape[1] > 1:\\n...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Experiment.ipynb\\\".\\nThe first task is:\\nAlso, we can tune the parameters. Let's see what will happen!\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# for C=3\\nlr = LogisticRegression(C=3)\\nlr.fit(X_train, Y_train)\\ny = lr.predict(X_test)\\naccuracy_score(Y_test, y)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Adding the predictor results in a higher loo than the intercept-only model.\\n\",\"targets\":\"ppc= model_lag.predict(lag_fitted, kind=\\\"pps\\\", draws=1000)\\naz.plot_ppc(lag_fitted);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And use update_dice to do the updates.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nupdate_dice(pmf, 1)\\nupdate_dice(pmf, 7)\\npmf\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"Aggregation basics\\nOne of the essential table API functions is aggregate. Aggregation involves the following\\n\\nOne or more named aggregate expressions, or reductions\\nZero or more grouping expressions or column names\\n\\nThis ends up working very similarly to pandas's groupby mechanism.\\nLet's start with a simple reduction:\\n\",\"targets\":\"metric = table.double_col.sum()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"And for the summary we'll use an equivalent method, DataFrame.describe():\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nNBA.describe()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"%%time\\n\\nreload(ppl)\\n\\nestimator = 'knn'\\n\\nmodel_name = 'pca_%s'%(estimator_name)\\n\\noptimized_pipeline_kwargs = {\\n 'transform_type': 'pca'\\n}\\n\\n# Initialize pipeline\\noptimized_pipeline = ppl.OptimizedPipeline(estimator,**optimized_pipeline_kwargs)\\n\\n# Set pipeline fitting parameters\\nfit_kwargs = {\\n 'random_state': 6,\\n 'use_default_param_dist': True,\\n 'suppress_output': True\\n}\\n\\n# Fit data\\noptimized_pipeline.fit(X,y,**fit_kwargs)\\n\\n# Save \\noptimized_pipelines[model_name] = optimized_pipeline\\n \\n# Visualize results\\npipeline_keys = optimized_pipelines.keys()\\n\\ntest_scores = [optimized_pipelines[key].test_score_ for key in pipeline_keys]\\n\\nax = pd.Series(test_scores,index=pipeline_keys).sort_values().plot(kind='barh',color='black')\\n\\nprint optimized_pipelines['pca_knn']\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nKNN with pre-processing transforms\\nCurrently Principal Component Analysis (PCA) and t-distributed stochastic neighbor embedding (t-SNE) are supported as pre-processing options.\\nKNN with PCA pre-processing\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"NOTEBOOKS\\/PROBLEMA_4_16.ipynb\\\".\\nThe first task is:\\nPor lo que el valor de corte máximo (que es la condición de falla) es:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntaumax = np.abs(sigmaWPb[0,0]) \\/ 2.0\\nprint 'taumax =', taumax\\nprint\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Practicas\\/.ipynb_checkpoints\\/Practica 5 - Modelado de Robots-checkpoint.ipynb\\\".\\nThe first task is:\\nEn este punto ya tenemos nuestros datos de la simulación, tan solo queda graficarlos para interpretar los resultados:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%matplotlib inline\\nfrom matplotlib.pyplot import style, plot, figure\\nstyle.use(\\\"ggplot\\\")\\n\\nfig1 = figure(figsize = (8, 8))\\n\\nax1 = fig1.gca()\\n\\nax1.plot(xs);\\n\\nfig2 = figure(figsize = (8, 8))\\n\\nax2 = fig2.gca()\\n\\nax2.plot(qs)\\nax2.plot(q̇s);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"\\\"\\\" \\nThis here is a multi-line comment.\\nMake sure to end it with matching quotes!\\n\\\"\\\"\\\"\\nprint \\\"Aye aye!\\\"\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nYou can also make comments that span multiple lines, using triple quotes (\\\"\\\"\\\") like so:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"\\\"Create a DataFrame from a dict of Series:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndata_2 = {'VA' : df_4['VA'][1:],\\n 'MD' : df_4['MD'][2:]}\\ndf_5 = pd.DataFrame(data_2)\\ndf_5\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n" "{\"inputs\":\"I am working on the file \\\"Challenge Build your own NLP model.ipynb\\\".\\nThe first task is:\\nThe model is evaluated on the test set. In this case the solver has been chosen between the different options that support multiclass classification. As it can be seen in the classification report the model presents overfitting being the precision and recall close to one in all classes expect for class five (Huxley) which is the one that reduces the overall accuracy of the model.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#Evaluation of the model (testing)\\n\\ntarget_names = ['0.0', '1.0', '2.0', '3.0']\\n\\nprint(('Classification Report BoW: \\\\n {}')\\n .format(classification_report(y_test_bow, predtest_y_bow,\\n target_names=target_names)))\\n\\nconfusion_bow = confusion_matrix(y_test_bow, predtest_y_bow)\\n\\nprint(('Confusion Matrix BoW: \\\\n\\\\n {}\\\\n'\\n).format(confusion_bow))\\n\\nprint(('Logistic Regression set accuracy BoW: {0:.2f} % \\\\n'\\n).format(cross_val_score(log_reg_tuned_bow, X_test_bow, y_test_bow,cv=kf).mean()*100\\n ))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"

This is quite unreadable and pointless!<\\/h2>\\n\\n