"{\"inputs\":\"Call has the highest mean price, while suicide has the lowest\\nPlot price for different types\\n\",\"targets\":\"tx = df[df['type'] == 'tx']\\ncall = df[df['type'] == 'call']\\ncreate = df[df['type'] == 'create']\\nsuicide = df[df['type'] == 'suicide']\\n\\nplt.hist(tx['price_gwei'], bins=4000, color='b', alpha=0.7)\\nplt.xlim(-10,100)\\nplt.title('tx', fontsize=18)\\nplt.xlabel('price', fontsize=18)\\nplt.show()\\n\\nplt.hist(call['price_gwei'], bins=4000, color='b', alpha=0.7)\\nplt.xlim(-10,100)\\nplt.title('call', fontsize=18)\\nplt.xlabel('price', fontsize=18)\\nplt.show()\\n\\nplt.hist(create['price_gwei'], bins=50, color='b', alpha=0.7)\\nplt.xlim(-10,100)\\nplt.title('create', fontsize=18)\\nplt.xlabel('price', fontsize=18)\\nplt.show()\\n\\nplt.hist(suicide['price_gwei'], bins=10, color='b', alpha=0.7)\\nplt.xlim(-10,100)\\nplt.title('suicide', fontsize=18)\\nplt.xlabel('price', fontsize=18)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"4. Alltogether\\n\",\"targets\":\"ns1 = NS('n', dim=2).truncate(2.0, 0.8, lambda m: np.sum(np.abs(m), axis=1)) + 4\\nns2 = 2 * NS('u', dim=2).truncate(1, expr=lambda m: np.sum(m, axis=1)) - (1, 1)\\nns3 = NS('n', dim=2).truncate(1.5, expr=lambda m: np.sum(np.square(m), axis=1)) + (4, 0)\\nns4 = ((NS('n', dim=2).truncate(2.5, expr=lambda m: np.sum(np.square(m), axis=1)) * 4)\\n       .apply(lambda m: m.astype(np.int)) \\/ 4 + (0, 3))\\nns = 0.4 & ns1 | 0.2 & ns2 | 0.39 & ns3 | 0.01 & ns4\\n\\nplt.imshow(np.histogramdd(ns.sample(int(1e6)), bins=100, normed=True)[0])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%file my_parametrized_fixture.py\\n\\nimport pytest\\n\\ndef g(a):\\n    return 2 * a\\n\\n@pytest.fixture(params=[10, 50, 100])\\ndef numbers(request):\\n    return request.param\\n    \\ndef test_g(numbers):\\n    assert g(numbers) == numbers + numbers\\n    \\ndef test_2g(numbers):\\n    assert g(2*numbers) == 4 * numbers\\n\\n!py.test -v my_parametrized_fixture.py\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExtended fixtures\\nFixtures can be parametrized, which means they can take multiple values. \\nThe parameters are given as a list to the keyword params.\\nTo access these parameters inside the fixture definition, one must use the request argument and call the param attribute from request (see below in the my_parametrized_fixture.py file definition)\\nA test using a parametrized fixture will then correspond to a loop test over the parameter set of the fixture. We define here the fixture numbers that can take 3 values: 10, 50 and 100. Any test using the fixture numbers will run three times, with numbers taking respectively the value 10, 50 and 100 .\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"6.\\nWhat combination of countries and varieties are most common? Create a Series whose index is a MultiIndexof {country, variety} pairs. For example, a pinot noir produced in the US should map to {\\\"US\\\", \\\"Pinot Noir\\\"}. Sort the values in the Series in descending order based on wine count.\\n\",\"targets\":\"country_variety_counts = ____\\n\\n# Check your answer\\nq6.check()\\n\\n#%%RM_IF(PROD)%%\\ncountry_variety_counts = reviews.groupby(['country', 'variety']).size().sort_values(ascending=False)\\n\\nq6.assert_check_passed()\\n\\n#_COMMENT_IF(PROD)_\\nq6.hint()\\n#_COMMENT_IF(PROD)_\\nq6.solution()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Day 2 - Unit 3.1.ipynb\\\".\\nThe first task is:\\n2.3.3 Combining line styles with color abbrevations\\nThe nice thing about plot is that it accepts as an argument the following convenience syntax: We can combine both line styles, marker styles and color into one single 2 (or 3 length string). Here are some examples. \\n\\n'-or' means plot a solid line, with a circle marker at the data points in red.\\n'bD' means plot a blue diamond marker scatter plot. \\n\\nWe use marker codes like this to tell plot whether to plot a line plot or a scatterplots. This is necessary because from plot point of view, there is no essential difference between one and another; a line plot (or time series plot) is created from a scatter plot by interpolating between succesive entries in the Series passed to plot. \\nHere below, we shall use this knowledge to plot a simple scatter plot to show the correlation between percentage change in stock prices of both Google (resp. 3M) and Apple.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfig3, ax3 = plt.subplots(figsize=(6,6))\\n\\nmarker = [\\\"go\\\", \\\"rD\\\"]\\nfor mark, ticker in zip(marker, tickers[1:]):\\n    ax3.plot(closing_pct_change[\\\"AAPL\\\"], closing_pct_change[ticker], mark, label=ticker, alpha=0.5)\\n    \\nax3.set_xlabel(\\\"AAPL Percentage change\\\")\\nax3.set_title(\\\"Correlation of Percentage changes in closing stock price\\\")\\nplt.legend(loc=\\\"best\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Astropy provides functionality for reading in and manipulating tabular\\ndata through the astropy.table subpackage. An additional set of\\ntools for reading and writing ASCII data are provided with the\\nastropy.io.ascii subpackage, but fundamentally use the classes and\\nmethods implemented in astropy.table.\\nWe'll start by importing the ascii subpackage:\\n\",\"targets\":\"from astropy.io import ascii\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Running in debug mode we can see all ssh arguments injected via anisble. Discuss the DEBUG output       \\n!sed -i 's\\/ansible_password\\/#ansible_password\\/' inventory\\n!ansible -vvv -m ping all\\n\\n# Use this cell for the exercise\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise\\nComment out the ansible_password field  in inventory here\\n\\nguess the expected output without running ansible\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"## run steps of an ipyrad assembly on a specific ipcluster instance\\ndata = ip.Assembly(\\\"example\\\")\\ndata.set_params(\\\"sorted_fastq_path\\\", \\\"example_empirical_rad\\/*.fastq.gz\\\")\\ndata.run(\\\"1\\\", ipyclient=mpi)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExample of using a Client in an ipyrad assembly\\nHere we create an Assembly and when we call the .run() command we provide a specific ipyclient object as the target to distribute work on. If you do not provide this option then by default ipyrad will look for an ipcluster instance running on the default profile (\\\"\\\").\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\".iloc()\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# .iloc slicing at specific location - BY POSITION in the table\\n# Recall:\\n# dfg[a:b] by rows\\n# dfg[[col]] or df[[col1, col2]] by columns\\n# df.loc[a:b, x:y], by index and column values + location\\n# df.iloc[3:5,0:2], numeric position in table\\n\\ndfg.iloc[1:4,3:5] # 2nd to 4th row, 4th to 5th column\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Notar que los índices se indican como Major_axis\\ncloses = panel_data.ix['Adj Close']\\ncloses\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nComo antes, solo nos interesan los precios de cierre ajustados...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Below creates a dataframe for all jobs without salaries, then drops duplicate records from that dataframe.\\n\",\"targets\":\"## Extracting all fields with missing salaries for analysis and estimation later\\n\\nindeed.salary = indeed.salary.astype(str)\\nindeed_missing = indeed[indeed['salary'] == 'None']\\n\\n## Drop duplicate scraped records\\nindeed_missing[['title','location','company','salary']].drop_duplicates(inplace = True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Changing the Objectives\\nThe objective function is determined from the objective_coefficient attribute of the objective reaction(s). Currently in the model, there is only one objective reaction, with an objective coefficient of 1.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmodel.objective\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Authors: Christopher Holdgraf <choldgraf@berkeley.edu>\\n#\\n# License: BSD (3-clause)\\nfrom scipy.io import loadmat\\nimport numpy as np\\nfrom mayavi import mlab\\nfrom matplotlib import pyplot as plt\\nfrom os import path as op\\n\\nimport mne\\nfrom mne.viz import ClickableImage  # noqa\\nfrom mne.viz import plot_alignment, snapshot_brain_montage\\n\\n\\nprint(__doc__)\\n\\nsubjects_dir = mne.datasets.sample.data_path() + '\\/subjects'\\npath_data = mne.datasets.misc.data_path() + '\\/ecog\\/sample_ecog.mat'\\n\\n# We've already clicked and exported\\nlayout_path = op.join(op.dirname(mne.__file__), 'data', 'image')\\nlayout_name = 'custom_layout.lout'\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n====================================================\\nHow to convert 3D electrode positions to a 2D image.\\n====================================================\\nSometimes we want to convert a 3D representation of electrodes into a 2D\\nimage. For example, if we are using electrocorticography it is common to\\ncreate scatterplots on top of a brain, with each point representing an\\nelectrode.\\nIn this example, we'll show two ways of doing this in MNE-Python. First,\\nif we have the 3D locations of each electrode then we can use Mayavi to\\ntake a snapshot of a view of the brain. If we do not have these 3D locations,\\nand only have a 2D image of the electrodes on the brain, we can use the\\n:class:mne.viz.ClickableImage class to choose our own electrode positions\\non the image.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Again we have a very strong signal present in the recording. That is always nice to see. Analysis again is then straightforward:\\n\",\"targets\":\"#run analysis\\nwd, m = hp.process(hp.scale_data(data), sample_rate)\\n\\n#visualise in plot of custom size\\nplt.figure(figsize=(12,4))\\nhp.plotter(wd, m)\\n\\n#display computed measures\\nfor measure in m.keys():\\n    print('%s: %f' %(measure, m[measure]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%sql select * from Students\\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\":\"\\\"Can you find an even better value for K?\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# try K=1 through K=25 and record testing accuracy\\nk_range = range(1, 26)\\nscores = [] # calculate accuracies for each value of K!\\n\\n#Now we plot:\\n\\nimport matplotlib.pyplot as plt\\n# allow plots to appear within the notebook\\n%matplotlib inline\\n\\nplt.plot(k_range, scores)\\nplt.xlabel('Value of K for KNN')\\nplt.ylabel('Testing Accuracy')\\n\\n# try K=1 through K=25 and record testing accuracy\\nk_range = range(1, 26)\\nscores = []\\nfor k in k_range:\\n    knn = KNeighborsClassifier(n_neighbors=k)\\n    knn.fit(X_train, y_train)\\n    y_pred = knn.predict(X_test)\\n    scores.append(metrics.accuracy_score(y_test, y_pred))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"!py.test -v spectra_analysis\\/tests\\/\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<div class=\\\"alert alert-success\\\">\\n\\n<b>EXERCISE<\\/b>:<br>\\nSame as above, implement tests for the two methods.<br><br>\\n\\nAdvice:\\n\\n<ul>\\n  <li>Start by defining a common array for both tests\\n  <pre><code class=\\\"python language-python\\\">\\n  X = np.array([[0, 0, 0],\\n                [0, 0, 0],\\n                [1, 1, 1],\\n                [1, 1, 1],\\n                [1, 1, 1],\\n                [2, 2, 2]])\\n  <\\/code><\\/pre>\\n                  <\\/li>\\n  <li>Compute the expected output of the methods applied on this array<\\/li>\\n<\\/ul>\\n<\\/div>\\n\\nAgain, verify that the tests pass.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"According to the plot it is obvious that male passengers had a significant lower chance of survival in comparison to female passengers. \\n3.2 Did the social-economic status determine the chances of survival?\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n################################ Survival regarding the fare ##########################\\n# Create a dataframe of all fares\\nfares_df=titanic[[\\\"Fare\\\", \\\"Survived\\\"]]\\nfares=titanic[\\\"Fare\\\"]\\n\\n# Create 20 fare ranges from 0 $ - 300 $ and count how many fares from fares_df belong to each range\\nnum_bins=20\\nbar_width=300\\/float(num_bins)\\nfare_ranges_all=[]\\nfor i in np.arange(0,num_bins,1):\\n    fare_ranges_all.append(len([x for x in fares if i*bar_width <= x < (i+1)*bar_width]))\\n\\n# Create a dataframe with fares of passengers who survived\\nsurvived_fares=fares_df.ix[(fares_df[\\\"Survived\\\"]==1)][\\\"Fare\\\"]\\n\\n# Determine how many fares of passengers who survived belong in each of the 20 ranges \\nfare_ranges_survived=[]\\nfor i in np.arange(0,num_bins,1):\\n    fare_ranges_survived.append(len([x for x in survived_fares if i*bar_width <= x < (i+1)*bar_width]))\\n\\n# Handle the case in which a fare range does not contain any counts (to avoid devide by null error during normalization)\\nfor n,i in enumerate(fare_ranges_all):\\n    if i==0:\\n      fare_ranges_all[n]=1\\n \\n \\n################################ Survival regarding the class ##########################\\n \\n# Get the Groupby object \\ng=titanic.groupby([\\\"Survived\\\",\\\"Pclass\\\"])\\n\\n# Count the passengers from each class who not have survived\\ndead_class_1=g.get_group((0,1))[\\\"PassengerId\\\"].count()\\ndead_class_2=g.get_group((0,2))[\\\"PassengerId\\\"].count()\\ndead_class_3=g.get_group((0,3))[\\\"PassengerId\\\"].count()\\n\\n# Count the passengers from each class who  have survived\\nsurvived_class_1=g.get_group((1,1))[\\\"PassengerId\\\"].count()\\nsurvived_class_2=g.get_group((1,2))[\\\"PassengerId\\\"].count()\\nsurvived_class_3=g.get_group((1,3))[\\\"PassengerId\\\"].count()\\n\\n# Get the Groupby object\\ng=titanic.groupby([\\\"Pclass\\\"])\\n# Count the passengers in each class\\npassengers_class1=float(g.get_group((1))[\\\"PassengerId\\\"].count())\\npassengers_class2=float(g.get_group((2))[\\\"PassengerId\\\"].count())\\npassengers_class3=float(g.get_group((3))[\\\"PassengerId\\\"].count())\\n\\n\\n\\n\\n\\n\\n# Plot the fare-survival relation\\n\\nfig, axes = plt.subplots(nrows=1, ncols=2,...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# PROPERTY ID - DO NOT EDIT !  \\nDOC.set_id('cmip6.land.nitrogen_cycle.overview')  \\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\":\"\\n29. Nitrogen Cycle\\nLand surface nitrogen cycle\\n29.1. Overview\\nIs Required: TRUE&nbsp;&nbsp;&nbsp;&nbsp;Type: STRING&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 1.1\\nOverview of the nitrogen cycle in the land surface\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Solution goes here\\n\\n# Solution goes here\\n\\n# Solution goes here\\n\\n# Solution goes here\\n\\n# Solution goes here\\n\\n# Solution goes here\\n\\n# Solution goes here\\n\\n# Solution goes here\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise: Suppose we have established that A is taller than B, but we don't know how tall B is.\\nNow we choose a random woman, C, and find that she is shorter than A by at least 15 cm.  Compute posterior distributions for the heights of A and C.\\nThe average height for women in the U.S. is 163 cm; the standard deviation is 7.3 cm.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Run OpenMC\\nopenmc.run()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow we a have a complete set of inputs, so we can go ahead and run our simulation.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"1_Radio_Science\\/1_11_modern_interferometric_arrays.ipynb\\\".\\nThe first task is:\\nFigure 1.11.7: ASKAP phased-array feed telescope. Credit: CSIRO&#10548;\\nAt the prime focus of each dish is a PAF which is used to form multiple 'beams' and increase the effective field of view of the dish. The dish mount has a 'third-axis' which corrects for the rotation of the PAF due to change in parallactic angle. This axis is necessary to keep the PAF 'beams' fixed to a position in the sky. The details of PAFs are not covered in this book, for those interested see the <cite data-cite='mailloux2005phased'>Phased Array Antenna Handbook<\\/cite> &#10548;.\\n| Dish Specifications |\\n|:---:|:---:|\\n| Optics | Prime Focus |\\n| Diameter | 12 m|\\n| $\\\\Delta \\\\theta_{1.4 GHz}$ | 1.22 deg |\\nTable 1.11.10 Dish specifications for ASKAP\\nThe PAFs operate at L-band, they have a higher system temperature and smaller bandwidth coverage compared to MeerKAT, but can make up for this in survey science by covering a larger field of view for a fixed time.\\n| Receivers |\\n|:---:|:---:|\\n| Band | L |\\n| $T_{sys}$ | $50 K$ |\\n| Start Frequency | 700 MHz |\\n| Stop Frequency | 1800 MHz |\\n| Total Bandwidth | 1100 MHz |\\n| Instantaneous Bandwidth | 300 MHz |\\n| Fractional Bandwidth | 0.18 - 0.35 |\\n| Polarization | Dual Linear |\\nTable 1.11.11 Receiver specifications for ASKAP\\nThe phased-array feeds have been upgraded to a second generation version which has greatly reduced the system temperature. Below is a close-up of the first generation 'checker board' PAF. The  green panel is an active component which is used to form multiple digital beams.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nImage(filename='figures\\/arrays\\/askap_paf_2010.jpg')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"3.1 It's All Quite Logical\\nRead the code in the code cell below.\\n\",\"targets\":\"x = 1\\nif x > 0 and x < 5:\\n    print(\\\"Joe\\\")\\n    \\nif x > 0 or x < 5:\\n    print(\\\"Aled\\\")\\n    \\nif not(x > 0):\\n    print(\\\"Sarah\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"People Watching.ipynb\\\".\\nThe first task is:\\nLooks reasonable, other than that there are some unlikely outliers of people either living to an unrealistically mature age or worse, dying before they were born. When processing lots of data from Wikipedia you have to expect that you end up with a small number of parsing errors.\\nBy occupation\\nNow we'll group the data by occupation to get a rough idea of which occupations have the best life expectancy.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntop_jobs = [*df.groupby('occupation').count().sort_values('life_span').reset_index()[['occupation', 'life_span']].tail(60)['occupation']]\\nlife_expentancy = df.dropna().groupby('occupation')['life_span'].mean().sort_values()\\nlife_expentancy\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Lightcurve\\/Analyze light curves chunk by chunk - an example.ipynb\\\".\\nThe first task is:\\nR.m.s. - intensity diagram\\nThis diagram is used to characterize the variability of black hole binaries and AGN (see e.g. Plant et al., arXiv:1404.7498; McHardy 2010 2010LNP...794..203M for a review).\\nIn Stingray it is very easy to calculate.\\nSetup: simulate a light curve with a variable rms and rate\\nWe simulate a light curve with powerlaw variability, and then we rescale\\nit so that it has increasing flux and r.m.s. variability.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom stingray.simulator.simulator import Simulator\\nfrom scipy.ndimage.filters import gaussian_filter1d\\nfrom stingray.utils import baseline_als\\nfrom scipy.interpolate import interp1d\\n\\n\\nnp.random.seed(1034232)\\n# Simulate a light curve with increasing variability and flux\\nlength = 10000\\ndt = 0.1\\ntimes = np.arange(0, length, dt)\\n\\n# Create a light curve with powerlaw variability (index 1), \\n# and smooth it to eliminate some Gaussian noise. We will simulate proper\\n# noise with the `np.random.poisson` function.\\n# Both should not be used together, because they alter the noise properties.\\nsim = Simulator(dt=dt, N=int(length\\/dt), mean=50, rms=0.4)\\ncounts_cont = sim.simulate(1).counts\\ncounts_cont_init = gaussian_filter1d(counts_cont, 200)\\n\\n# ---------------------\\n# Renormalize so that the light curve has increasing flux and r.m.s. \\n# variability.\\n# ---------------------\\n\\n\\n# The baseline function cannot be used with too large arrays. \\n# Since it's just an approximation, we will just use one every\\n# ten array elements to calculate the baseline\\nmask = np.zeros_like(times, dtype=bool)\\nmask[::10] = True\\nprint (counts_cont_init[mask])\\n\\nbaseline = baseline_als(times[mask], counts_cont_init[mask], 1e10, 0.001)\\nbase_func = interp1d(times[mask], baseline, bounds_error=False, fill_value='extrapolate')\\n\\ncounts_cont = counts_cont_init - base_func(times)\\n\\ncounts_cont -= np.min(counts_cont)\\ncounts_cont += 1\\ncounts_cont *= times * 0.003\\n# counts_cont += 500\\ncounts_cont += 500\\n\\n\\n# Finally, Poissonize it!\\ncounts = np.random.poisson(counts_cont)\\nplt.plot(times, counts_cont, zorder=10, label='Continuous light curve')\\nplt.plot(times, counts, label='Final light curve')\\n\\nplt.legend()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Chapters-colab\\/Chapter_03_Strings.ipynb\\\".\\nThe first task is:\\nRemove all spaces in the sentence using a string method.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmy_string = \\\"Humpty Dumpty sat on the wall\\\"\\n# your code here\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<div class=\\\"alert alert-danger\\\"><strong>This is how the categorical embeddings are passed into the layers.<\\/strong><\\/div>\\n\",\"targets\":\"class TabularModel(nn.Module):\\n\\n    def __init__(self, emb_szs, n_cont, out_sz, layers, p=0.5):\\n        super().__init__()\\n        self.embeds = nn.ModuleList([nn.Embedding(ni, nf) for ni,nf in emb_szs])\\n        self.emb_drop = nn.Dropout(p)\\n        self.bn_cont = nn.BatchNorm1d(n_cont)\\n        \\n        layerlist = []\\n        n_emb = sum((nf for ni,nf in emb_szs))\\n        n_in = n_emb + n_cont\\n        \\n        for i in layers:\\n            layerlist.append(nn.Linear(n_in,i)) \\n            layerlist.append(nn.ReLU(inplace=True))\\n            layerlist.append(nn.BatchNorm1d(i))\\n            layerlist.append(nn.Dropout(p))\\n            n_in = i\\n        layerlist.append(nn.Linear(layers[-1],out_sz))\\n            \\n        self.layers = nn.Sequential(*layerlist)\\n    \\n    def forward(self, x_cat, x_cont):\\n        embeddings = []\\n        for i,e in enumerate(self.embeds):\\n            embeddings.append(e(x_cat[:,i]))\\n        x = torch.cat(embeddings, 1)\\n        x = self.emb_drop(x)\\n        \\n        x_cont = self.bn_cont(x_cont)\\n        x = torch.cat([x, x_cont], 1)\\n        x = self.layers(x)\\n        return x\\n\\ntorch.manual_seed(33)\\nmodel = TabularModel(emb_szs, conts.shape[1], 2, [200,100], p=0.4) # out_sz = 2\\n\\nmodel\",\"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-titanic\\/statement-importance\\/statement-importance.ipynb\\\".\\nThe first task is:\\n2. Оставьте в выборке четыре признака: класс пассажира (Pclass), цену билета (Fare), возраст пассажира (Age) и его пол (Sex).\\n3. Обратите внимание, что признак Sex имеет строковые значения.\\n4. Выделите целевую переменную — она записана в столбце Survived.\\n5. В данных есть пропущенные значения — например, для некоторых пассажиров неизвестен их возраст. Такие записи при чтении их в pandas принимают значение nan. Найдите все объекты, у которых есть пропущенные признаки, и удалите их из выборки.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf_no_missing = df[['Survived', 'Pclass', 'Fare', 'Age', 'Sex']].dropna()\\nX_train_withStrings = df_no_missing[['Pclass', 'Fare', 'Age', 'Sex']]\\ny_train = df_no_missing['Survived']\\n\\ndef strings_to_int(df, target_column):\\n    df_mod = df.copy()\\n    targets_to_rename = df_mod[target_column].unique()\\n    map_to_int = {name: n for n, name in enumerate(targets_to_rename)}\\n    df_mod[target_column] = df_mod[target_column].replace(map_to_int)\\n\\n    return df_mod\\n\\nX_train = strings_to_int(X_train_withStrings, \\\"Sex\\\")\\nX_train.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"\\\"break\\\" and \\\"continue\\\" statements\\nbreak is used to exit a for loop or a while loop, whereas continue is used to skip the current block, and return to the \\\"for\\\" or \\\"while\\\" statement. A few examples:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Prints out 0,1,2,3,4\\n\\ncount = 0\\nwhile True:\\n    print(count)\\n    count += 1\\n    if count >= 5:\\n        break\\n\\n# Prints out only odd numbers - 1,3,5,7,9\\nfor x in range(10):\\n    # Check if x is even\\n    if x % 2 == 0:\\n        continue\\n    print(x)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# !!!! Also must have MM folder on system PATH\\n# mm_version = 'C:\\\\Micro-Manager-1.4'\\n# cfg = 'C:\\\\Micro-Manager-1.4\\\\SetupNumber2_05102016.cfg'\\nmm_version = 'C:\\\\Program Files\\\\Micro-Manager-2.0beta'\\ncfg = 'C:\\\\Program Files\\\\Micro-Manager-2.0beta\\\\Setup2_20170413.cfg'\\n\\nimport sys\\nsys.path.insert(0, mm_version) # make it so python can find MMCorePy\\nimport MMCorePy\\n\\nfrom PIL import Image\\n\\ncore = MMCorePy.CMMCore()\\ncore.loadSystemConfiguration(cfg)\\ncore.setProperty(\\\"Spectra\\\", \\\"White_Enable\\\", \\\"1\\\")\\ncore.waitForDevice(\\\"Spectra\\\")\\n\\ncore.setProperty(\\\"Cam Andor_Zyla4.2\\\", \\\"Sensitivity\\/DynamicRange\\\", \\\"16-bit (low noise & high well capacity)\\\") # NEED TO SET CAMERA TO 16 BIT (ceiling 12 BIT = 4096)\\n\\ncore.setProperty(\\\"Spectra\\\", \\\"White_Enable\\\", \\\"0\\\")\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nMicromanager\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"5. Spectral clustering algorithm\\n5.1. Affinity matrix\\nCompute and visualize the affinity matrix\\n\",\"targets\":\"from sklearn.metrics.pairwise import rbf_kernel\\n\\ngamma = 5\\nsf = 4\\nXsub = X[0::sf]\\nprint Xsub.shape\\ngamma = 0.001\\nK = rbf_kernel(Xsub, Xsub, gamma=gamma)\\n\\nplt.imshow(K, cmap='hot')\\nplt.colorbar()\\nplt.title('RBF Affinity Matrix for gamma = ' + str(gamma))\\nplt.grid('off')\\nplt.show()\\n\\nfrom sklearn.cluster import SpectralClustering\\n\\nspc = SpectralClustering(n_clusters=50, gamma=gamma, affinity='rbf')\\ny_kmeans = spc.fit_predict(Xsub)\\n\\nplt.scatter(Xsub[:,0], Xsub[:,1], c=y_kmeans, s=5, cmap='rainbow', linewidth=0.0)\\nplt.axis('equal')\\nplt.show()\\n\\nprint X[:,1]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Again, define the placeholders, variables, model, and cost function:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntrain_size, num_features = xs.shape\\n\\nX = tf.placeholder(\\\"float\\\", shape=[None, num_features])\\nY = tf.placeholder(\\\"float\\\", shape=[None, num_labels])\\n\\nW = tf.Variable(tf.zeros([num_features, num_labels]))\\nb = tf.Variable(tf.zeros([num_labels]))\\ny_model = tf.nn.softmax(tf.matmul(X, W) + b)\\n\\ncost = -tf.reduce_sum(Y * tf.log(y_model))\\ntrain_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)\\n\\ncorrect_prediction = tf.equal(tf.argmax(y_model, 1), tf.argmax(Y, 1))\\naccuracy = tf.reduce_mean(tf.cast(correct_prediction, \\\"float\\\"))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"&nbsp;\\n\\nhttps:\\/\\/leetcode.com\\/problems\\/largest-number-at-least-twice-of-others\\/description\\/\\n747. Largest Number At Least Twice of Others\\nIn a given integer array nums, there is always exactly one largest element.\\nFind whether the largest element in the array is at least twice as much as every other number in the array.\\nIf it is, return the index of the largest element, otherwise return -1.\\nExample 1:\\n```\\nInput: nums = [3, 6, 1, 0]\\nOutput: 1\\nExplanation: 6 is the largest integer, and for every other number in the array x,\\n6 is more than twice as big as x.  The index of value 6 is 1, so we return 1.\\n```\\nExample 2:\\nInput: nums = [1, 2, 3, 4]\\nOutput: -1\\nExplanation: 4 isn't at least as big as twice the value of 3, so we return -1. \\nNote:\\nnums will have a length in the range [1, 50].\\nEvery nums[i] will be an integer in the range [0, 99].\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n\\na=[1,2,4,5,3]\\n\\ndef find_largest(a):\\n    m = max(a)\\n    i = a.index(m)\\n    del a[i]\\n    m2 = max(a)\\n\\n    return i if m==0 or m\\/m2>=2 else -1\\n\\nfind_largest(a)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# 3-qubit W state, first and second steps\\nn = 3\\nq = QuantumRegister(n) \\nc = ClassicalRegister(n)\\nW_states = QuantumCircuit(q,c) \\n        \\nW_states.x(q[2]) #start is |100>\\nF_gate(W_states,q,2,1,3,1) # Applying F12\\nF_gate(W_states,q,1,0,3,2) # Applying F23\\n       \\nfor i in range(3) :\\n    W_states.measure(q[i] , c[i]) \\n\\nshots = 1024\\ntime_exp = time.strftime('%d\\/%m\\/%Y %H:%M:%S')\\nprint('start W state 3-qubit (steps 1 + 2) on', backend, \\\"N=\\\", shots,time_exp)\\nresult = execute(W_states, backend=backend, shots=shots)\\ntime_exp = time.strftime('%d\\/%m\\/%Y %H:%M:%S')\\nprint('end   W state 3-qubit (steps 1 + 2) on', backend, \\\"N=\\\", shots,time_exp)\\nplot_histogram(result.result().get_counts(W_states))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThree-qubit W state: adding step 2\\nIn the previous step you obtained an histogram compatible with the following state:\\n$$ |\\\\varphi_{1} \\\\rangle= F_{1,2}\\\\,  |\\\\varphi_{0} \\\\rangle\\\\,=F_{1,2}\\\\,  \\\\,|1 0 0 \\\\rangle=\\\\frac{1}{\\\\sqrt{3}} \\\\: |1 0 0 \\\\rangle \\\\: + \\\\sqrt{\\\\frac{2}{3}} \\\\: |1 1 0 \\\\rangle $$\\nNB: Depending on the backend, it happens that the order of the qubits is modified, but without consequence for the state finally reached.\\nWe seem far from the ultimate goal.\\nRun the following circuit to obtain $|\\\\varphi_{2} \\\\rangle =F_{2,3}\\\\, \\\\, |\\\\varphi_{1} \\\\rangle$\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"NLAhw\\/hw1\\/PS1.ipynb\\\".\\nThe first task is:\\n(3 pts) Set x=s[::20], num_iter=1000 and $\\\\alpha=\\\\frac{1}{5}$. Explain what happens with the convergence if you add small random noise of amplitude $10^{-3}\\\\max(x)$  to $y$. The answer to this question should be an explanation supported by plots and\\/or tables.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Your code is here\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<a id='Numb_alterations'><\\/a>\\nExercise 2.19: Number of distinct faces rolled in 6 rolls\\nLet X count the number of distinct faces rolled in 6 rolls of a fair six-sided die.  For example, if the result of the rolls is (3, 3, 3, 3, 3, 3) then X = 1; if (6, 4, 5, 4, 6, 6) then X=3; etc.  Use the number_distinct_values function defined below to define the RV X on an appropriate probability space.  Then simulate values of X and plot its approximate distribution.  (The number_distinct_values function takes as an input a list of values and returns as an output the number of distinct values in the list. We have used the Python functions set and len.)\\n\",\"targets\":\"def number_distinct_values(x):\\n    return len(set(x))\\n\\nnumber_distinct_values((1, 1, 4))\\n\\n### Type your commands in this cell and then run using SHIFT-ENTER.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Argumentos por defecto y argumentos de palabra clave\\nEn la definición de una función, podemos asignar valores por defecto a los argumentos de la función:\\n\",\"targets\":\"def mifunc(x, p=2, debug=False):\\n    if debug:\\n        print(\\\"evaluando mifunc para x = \\\" + str(x) + \\\" usando el exponente p = \\\" + str(p))\\n    return x**p\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create an undirected graph in igraph, from the dataframe edge-list, using Graph.TupleList and specifying directed=False. Print out the graph summary using the summary instance method.\\n\",\"targets\":\"grn_igraph = igraph.Graph.TupleList(interac_grn_unique.values.tolist(), directed=False)\\ngrn_igraph.summary()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"COMMIT YOUR WORK\\nDocumentation\\nAlong the same lines as testability and resusability is documenation.\\nWhile python is easy to read and follow, you will either need to share\\nyour code with others or you will forget what you did.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nhelp(round)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Barchart\\n\\nIdeal for comparing groups within the data set\\n\",\"targets\":\"plt.bar([1, 2, 3, 4], [455, 404, 317, 730], tick_label=[\\\"XI\\\", \\\"IX\\\", \\\"VIII\\\",\\\"V\\\"], align='center');\\nplt.xlabel(\\\"Districts\\\"); plt.ylabel(\\\"Avg price   [10^3 HUF\\/ m^2]\\\");\\nplt.title(\\\"Real estate prices in Budapest (2016)\\\");\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%R push X   is  equivalent to %R -i X\\n%R pull X   is  equivalent to %R -o X\\n\",\"targets\":\"b = %R a=resid(lm(Y~X))\\n%Rpull a\\nprint \\\"a\\\", a\\nprint \\\"b\\\", b\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<div class=\\\"alert alert-success\\\">This value is consistent with what ESA says! $7\\\\,060\\\\,160$ km<\\/div>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom IPython.display import HTML\\n\\nHTML(\\n\\\"\\\"\\\"<blockquote class=\\\"twitter-tweet\\\" data-lang=\\\"en\\\"><p lang=\\\"es\\\" dir=\\\"ltr\\\">La <a href=\\\"https:\\/\\/twitter.com\\/esa_es\\\">@esa_es<\\/a> ha preparado un resumen del asteroide <a href=\\\"https:\\/\\/twitter.com\\/hashtag\\/Florence?src=hash\\\">#Florence<\\/a> 😍 <a href=\\\"https:\\/\\/t.co\\/Sk1lb7Kz0j\\\">pic.twitter.com\\/Sk1lb7Kz0j<\\/a><\\/p>&mdash; AeroPython (@AeroPython) <a href=\\\"https:\\/\\/twitter.com\\/AeroPython\\/status\\/903197147914543105\\\">August 31, 2017<\\/a><\\/blockquote>\\n<script async src=\\\"\\/\\/platform.twitter.com\\/widgets.js\\\" charset=\\\"utf-8\\\"><\\/script>\\\"\\\"\\\"\\n)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"And multiply them by scalars:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n1.5 * u\\n\\n-1.5 * u\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Salah\\nx = np.array(1,2,3)  \\n\\n# Benar\\nx = np.array([1,2,3])\\n\\ny = np.array([[1,0,0],[0,1,0]])\\nz = np.array([(1,0,0),(0,1,0)])\\n\\ny-z\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nBeberapa kesalahan dalam membuat array seringkali terjadi karena kesalahan pada kurung. Ingat bahwa array ini adalah suatu fungsi, sehingga membutuhkan kurung biasa atau parenthesis sedangkan array membutuhkan kurung siku atau brackets. Pada prakteknya, ketika dimensi array lebih dari satu, setelah mengambil brackets di paling luar, menggunakan parenthesis lagi di dalam tidak masalah.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Advance usage: create new procedure\\nwill add description later\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom ddf_utils.chef.ingredient import Ingredient, ProcedureResult\\n\\ndef multiply_1000(chef, ingredients, result, **options):\\n    ingredients = [chef.dag.get_node(x) for x in ingredients]\\n    ingredient = ingredients[0].evaluate()\\n    \\n    new_data = dict()\\n    for k, df in ingredient.get_data().items():\\n        df_ = df.copy()\\n        df_[k] = df_[k] * 1000\\n        new_data[k] = df_\\n        \\n    return ProcedureResult(chef, result, ingredient.key, new_data)\\n\\nchef = Chef()\\nchef.add_config(ddf_dir=os.path.expanduser('~\\/src\\/work\\/Gapminder\\/datasets'))\\n\\ni = '''\\nid: cpi-datapoints\\ndataset: ddf--transpint--corrupton\\nkey: country, year\\nvalue: \\\"*\\\"\\n'''\\n\\nd = yaml.round_trip_load(i)\\nchef.add_ingredient(**d)\\n\\nchef.register_procedure(multiply_1000)\\n\\nchef.add_procedure(collection='datapoints',\\n                   procedure='multiply_1000',\\n                   result='res',\\n                   ingredients=['cpi-datapoints']\\n                  )\\n\\nres = chef.run()\\n\\nres[0].get_data()['cpi'].head(5)\\n\\nchef.ingredients\\n\\nchef.ingredients[0].get_data()['cpi'].head()  # the original\\n\\nchef.to_graph()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Compute residuals\\nThe GP hyperparameters are fit to the residuals from the ckwn white-noise analysis.\\n\",\"targets\":\"lpf = LPFTM()\\npv0 = pd.read_hdf(RFILE_EXT, 'ckwn\\/fc').median().values\\n\\nfluxes_m = lpf.compute_transit(pv0)\\nresiduals = [fo-fm for fo,fm in zip(lpf.fluxes, fluxes_m)]\\ngps = [GPTime(time, res) for time,res in zip(lpf.times, residuals)]\\nhps = []\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Because there are several steps in this assignment, we have introduced some stopping points where you can check your code and make sure it is correct before proceeding. To test your intermediate_node_num_mistakes function, run the following code until you get a Test passed!, then you should proceed. Otherwise, you should spend some time figuring out where things went wrong.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Test case 1\\nexample_labels = np.array([-1, -1, 1, 1, 1])\\nif intermediate_node_num_mistakes(example_labels) == 2:\\n    print 'Test passed!'\\nelse:\\n    print 'Test 1 failed... try again!'\\n\\n# Test case 2\\nexample_labels = np.array([-1, -1, 1, 1, 1, 1, 1])\\nif intermediate_node_num_mistakes(example_labels) == 2:\\n    print 'Test passed!'\\nelse:\\n    print 'Test 2 failed... try again!'\\n    \\n# Test case 3\\nexample_labels = np.array([-1, -1, -1, -1, -1, 1, 1])\\nif intermediate_node_num_mistakes(example_labels) == 2:\\n    print 'Test passed!'\\nelse:\\n    print 'Test 3 failed... try again!'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Data Manipulation (Plots)\\nNow that we have the data easily accessible in python, lets look at how to plot it. <code>Pandas<\\/code> allows you to use matplotlib to plot, however it is done using methods built into pandas.\\nAlthough the methods to create an manipulate plots are built into <code>Pandas<\\/code>, we will still have to import matplotlib to save and show the plots.\\n\",\"targets\":\"import matplotlib.pyplot as plt\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"NSC2006\\/labo1\\/labo_NSC2006_donnees_multidimentionnelles_Octave.ipynb\\\".\\nThe first task is:\\n<font color=\\\"red\\\"> <ol start=\\\"11\\\">\\n\\n<h4><li> Vous allez compléter, à partir du fichier , les 4 lignes de code\\n    manquante à l’interieure de la boucle pour tracer tous les essais\\n    (47) dans une même figure. Le résultat ressemblerait à la figure\\n    suivante: <\\/li><\\/h4>\\n&lt;\\/ol&gt;&lt;\\/font&gt;\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%%matlab\\n% Charger les donnees\\nload('Chap17_Data')\\n% Preparer une figure\\nfigure \\n% permettre la superposition de plusieurs graphiques dans la meme figure\\nhold on \\n% Donner un label à l'axe des x\\nxlabel('Temp (sec)'); \\n% Donner un label à l'axe des y\\nylabel('Essai #');\\n% Ajuster les limites de l'axe des y\\nylim([0 length(spike)]);\\n\\nfor num_spike = 1:length(spike) %faire une boucle pour tout les essaies\\n    t = spike(num_spike).times; %definir la variable pour chaque essai\\n    for num_temps=1:length(t) %faire une boucle pour tous les points temps\\n        line([t(num_temps) t(num_temps)], [0+(num_spike-1) 1+(num_spike-1)]); %dessiner une line pour chaque point temps t1(i) avec longueur de 1\\n    end\\nend\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<a id='model2'><\\/a>\\n(IMPLEMENTATION) Model 2: CNN + RNN + TimeDistributed Dense\\nThe architecture in cnn_rnn_model adds an additional level of complexity, by introducing a 1D convolution layer.  \\n<img src=\\\"images\\/cnn_rnn_model.png\\\" width=\\\"100%\\\">\\nThis layer incorporates many arguments that can be (optionally) tuned when calling the cnn_rnn_model module.  We provide sample starting parameters, which you might find useful if you choose to use spectrogram audio features.  \\nIf you instead want to use MFCC features, these arguments will have to be tuned.  Note that the current architecture only supports values of 'same' or 'valid' for the conv_border_mode argument.\\nWhen tuning the parameters, be careful not to choose settings that make the convolutional layer overly small.  If the temporal length of the CNN layer is shorter than the length of the transcribed text label, your code will throw an error.\\nBefore running the code cell below, you must modify the cnn_rnn_model function in sample_models.py.  Please add batch normalization to the recurrent layer, and provide the same TimeDistributed layer as before.\\n\",\"targets\":\"model_2 = cnn_rnn_model(input_dim=161, # change to 13 if you would like to use MFCC features\\n                        filters=200,\\n                        kernel_size=11, \\n                        conv_stride=2,\\n                        conv_border_mode='valid',\\n                        units=200)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Below, the jupyter magic command %%capture silently discards the output that is produced by the notebook Tic-Tac-Toe.ipynb.\\n\",\"targets\":\"%%capture\\n%run Tic-Tac-Toe.ipynb\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# for random forest\\nconfusion_matrix(y_train_5, forest_clf.predict(X_train))\\n\\nconfusion_matrix(y_train_5, y_train_5)  # if the prediction is 100% accurate\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWhere each row represents a actual class and each column represents a predicted class.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#plt.figure()\\nplt.rcParams['figure.figsize'] = (6, 3)\\n\\ni = 0\\nfor track2_image_file in [\\\"data\\/track_2_1.jpg\\\", \\\"data\\/track_2_2.jpg\\\", \\\"data\\/track_2_3.jpg\\\"]:\\n    track2_image = load_img(track2_image_file)\\n    track2_image = img_to_array(track2_image).astype(np.uint8)\\n    track2_image = track2_image[55:135, :, :]\\n    track2_image = imresize(track2_image, (32, 16, 3))\\n    \\n    yuv = cv2.cvtColor(track2_image.astype(\\\"uint8\\\"), cv2.COLOR_RGB2HSV)\\n    yuv[:, :, 0] = yuv[:, :, 0] * 0\\n    yuv[:, :, 2] = yuv[:, :, 2] * 0\\n    \\n    plt.subplot(1, 3, i+1)\\n    plt.imshow(yuv)\\n    plt.axis('off')\\n    \\n    i += 1\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nShow some examples from Track 2 with cropping, HSV (only S channel)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"As we mentioned, the created op is actually a protobuf object. Let's show the content.\\n\",\"targets\":\"print(\\\"Type of the created op is: {}\\\".format(type(op)))\\nprint(\\\"Content:\\\\n\\\")\\nprint(str(op))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"09_up_and_running_with_tensorflow.ipynb\\\".\\nThe first task is:\\nNext, let's use the %tensorboard extension to start the TensorBoard server. We need to point it to the root log directory:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%tensorboard --logdir {root_logdir}\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Como é feita a avaliação quando um dos operadores é uma função? Como é feita a avaliação quando uma função é aplicada a uma expressão?\\nExercício:\\nA função abaixo devolve o primeiro caracter duma \\\\emph{string}:\\n\",\"targets\":\"def primeiro(s):\\n    return s[0]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<div class=\\\"alert alert-success\\\">\\n\\n<b>EXERCISE<\\/b>\\n\\n <ul>\\n  <li>Make a bar plot with pandas of the mean of each of the stations in the year 2012 (check the documentation of Pandas plot to adapt the rotation of the labels) and make sure all bars have the same color.<\\/li>\\n  <li>Using the matplotlib objects, change the y-label to 'NO$_2$ concentration (µg\\/m³)<\\/li>\\n  <li>Add a 'darkorange' horizontal line on the ax for the y-value 40 µg\\/m³ (command for horizontal line from matplotlib: <code>axhline<\\/code>).<\\/li>\\n  <li><a href=\\\"visualization_01_matplotlib.ipynb\\\">Place the text<\\/a> 'Yearly limit is 40 µg\\/m³' just above the 'darkorange' line.<\\/li>\\n<\\/ul>\\n\\n<\\/div>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfig, ax = plt.subplots()\\ndata['2012':].mean().plot(kind='bar', ax=ax, rot=0, color='C0')\\nax.set_ylabel(\\\"NO$_2$ concentration (µg\\/m³)\\\")\\nax.axhline(y=40., color='darkorange')\\nax.text(0.01, 0.48, 'Yearly limit is 40 µg\\/m³',\\n        horizontalalignment='left', fontsize=13, \\n        transform=ax.transAxes, color='darkorange');\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Configurations\\n\",\"targets\":\"vocab = (\\\" $%'()+,-.\\/0123456789:;=?ABCDEFGHIJKLMNOPQRSTUVWXYZ\\\"\\n            \\\"\\\\\\\\^_abcdefghijklmnopqrstuvwxyz{|}\\\\n\\\")\\ngraph_path = r\\\".\\/graphs\\\"\\ntest_text_path = os.path.normpath(r\\\"..\\/Dataset\\/arvix_abstracts.txt\\\")\\nbatch_size=50\\nmodel_param_path=os.path.normpath(r\\\".\\/model_checkpoints\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2D Histogram\\nNow let's say we have multiple input arrays. We can calculate their joint distribution:\\n\",\"targets\":\"db = xr.DataArray(np.random.randn(nt, nx), dims=['time', 'x'],\\n                  name='bar') - 2\\n\\nhistogram(da, db, bins=[bins, bins]).plot()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Class argument explanation\\n\\ngens=1 :: # of generations. Gen 1 is the mother. Each subsequent gen is composed of daughters that become mothers.\\ny_end=100 :: Simulation end year.\\nlifespan=80 :: Lifespan of each generation (e.g., gen 1 is born in year 0 and dies in year 80). \\nbrth_age=25 :: Age at which each generation gives birth. A birth schedule can be input, as well, using an embedded class function. \\naverage_lact_time=[0.5]*5 :: an array (must have at least as many elements as # of gens), describing the lactation time period in years. \\nk_lac=[1e-2] * 5 :: an array (must have at least as many elements as # of gens), describing the 1st order lactation kinetic rate coefficient.  time period in years [1\\/years]. \\nk_elim=[np.log(2) \\/ 5] * 5 ::  an array (must have at least as many elements as # of gens), describing the 1st order congener elemination kinetic rate coefficient [1\\/years]. Kinetics can also be determined by inspection of the biomonitoring data for an individual congener, as well. \\nodes_in_each_generation=2 :: the number of ode's in each gen (e.g., 2: one for body mass and one for concentration of congener in person).\\n\\nProblem statement\\nIn this example, let's solve some problems: \\n1. What is the time concentration profile of a congener in each of the 5 generations since the introduction of the chemical?\\n2. Which generation is at the highest risk? \\n3. How does the concentration of a congener vary throughout each generation (e.g., what is the concentration of the congener for 20 year olds of each generation)?\\ninitialize the pk_milk class.\\n\\nassume the birth age is 25, so 5 generations is 125 years for the 5th gen to be born. For a lifespan of 80 years, this means that the simulation should end at: 125 + 80 or 205 years.\\nassume that the average lactation time for each generation is 10 months. \\nassume that the 1st order lactation coefficient is 1e-1 [1\\/years]. \\nassume that the 1st order kinetic elimination coefficient is log(2)\\/5 [1\\/years]. Note: k_elim can also be calculated for each congener, which will...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npk_milk_base = pk_milk(gens=3, y_end=230,lifespan=80, \\n                       brth_age = 25, average_lact_time=[10\\/12]*5,\\n                      k_lac=[1e-2] * 5, k_elim=[np.log(2) \\/ 5] * 5)\\n\\n# calculate and set the delta_t. \\npk_milk_base.dt_from_timesteps_(timestep_variable=10, method='timesteps_per_month')\\n\\n# calculate and set the number of simulation timesteps\\npk_milk_base.n_steps_()\",\"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\\/01-python-jupyter-notebook\\/Python-101.ipynb\\\".\\nThe first task is:\\nAo dividir dois números (inteiros ou flutuantes), podemos fazer a divisão comum (\\/) ou divisão inteira (\\/\\/), onde a última mantém apenas a parte inteira do resultado\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(\\\"Divisao: \\\",1 \\/ 2)\\nprint(\\\"Divisao inteira: \\\",1 \\/\\/ 2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"A very small p-value: this means that the observed mean r value (0.397) is larger than what we would expect by chance. Note that your calculated p-value might deviate slightly from ours given the randomness in a simulation.\\nRepeat the procedure for all taxa.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfor t in get_taxa_list(taxa):\\n    print(get_p_value_for_mean_r(taxa, r_values, t, 50000))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Counter\\nCounter是一个简单的计数器，例如，统计字符出现的个数：\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Counter类的目的是用来跟踪值出现的次数,以字典的键值对形式存储，其中元素作为key，其计数作为value\\n# 下面这个例子就是使用 Counter 模块统计一段句子里面所有字符出现次数\\n\\nfrom collections import Counter\\n\\ns = 'A Counter is a dict subclass. '.lower()\\n\\nc = Counter(s)\\n# 获取出现频率最高的5个字符\\nprint(c.most_common(5))\\n\\n# 是否可以统计中文呢？\\n\\ns = '他会自己长大远去我们也各自远去'\\n\\nc = Counter(s)\\n\\nprint(c.most_common(5))\\n\\n# Counter 举例，用户输入内容\\n\\nfrom collections import Counter\\n\\ns = input('Please input:')\\n\\ns = s.lower()\\n\\nc = Counter(s)\\n# 获取出现频率最高的5个字符\\nprint(c.most_common(5))\\n\\n# 读出 Counter 对象中的key 和value\\n\\ns = 'A Counter is a dict subclass. '.lower()\\nc = Counter(s)\\n\\n# 用列表生成式获得 counter 中的 key\\nlist1 = [k for k,v in c.most_common()]\\n\\n# 用列表生成式获得 counter 中的 value\\nlist2 = [v for k,v in c.most_common()]\\nprint(list1)\\nprint(list2)\\n\\n# 我们在 notebook 中画个图\\n\\nimport matplotlib.pyplot as plt\\n \\nplt.bar(range(len(list2)), list2,color='rgb',tick_label=list1)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2) Approximate the probability that the Y is less than 2.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsims.count_lt(1)\\/10000\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"GAN\\/fashion_mnist_gan\\/fashion_mnist_gan_v2.ipynb\\\".\\nThe first task is:\\ndefine the GAN class\\nthe call() method is the 'action' of the model - make it running\\nCan you write Python code for it?\\n\",\"targets\":\"\\n\\n\\nclass DCGAN_V2():\\n  \\n    def __init__(self):\\n        \\n        # The results are a little better when the dimensionality of the random vector is only 10.\\n        # The dimensionality has been left at 100 for consistency with other GAN implementations.\\n        self.randomDim = 100\\n\\n        # Load data\\n        (X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()\\n        X_train = (X_train.astype(np.float32) - 127.5)\\/127.5\\n        #self.X_train = np.expand_dims(X_train, -1)\\n        self.X_train = X_train[:, np.newaxis, :, :]\\n\\n        self.tensorboard = keras.callbacks.TensorBoard(log_dir=JOB_DIR+ \\\"\\/logs\\\",\\n                                                        batch_size=BATCH,\\n                                                        write_graph=True,\\n                                                        histogram_freq=0,\\n                                                        write_images=True,\\n                                                        write_grads=True)\\n        #self.checkpointer  = keras.callbacks.ModelCheckpoint(filepath=f'{FLAGS.job_dir}\\/gan_model.best.hdf5', verbose = 1, save_best_only=True)\\n\\n        # Optimizer\\n        self.optimizer = Adam(lr=0.0002, beta_1=0.5)\\n\\n        self.discriminator = self.build_D()\\n        self.generator = self.build_G()\\n\\n        # Combined network\\n        self.discriminator.trainable = False\\n        ganInput = Input(shape=(self.randomDim,))\\n        x = self.generator(ganInput)\\n        ganOutput = self.discriminator(x)\\n        self.gan = Model(inputs=ganInput, outputs=ganOutput)\\n        self.gan.compile(loss='binary_crossentropy', optimizer=self.optimizer)\\n\\n        self.dLosses = []\\n        self.gLosses = []\\n\\n\\n    def build_G(self):\\n      with tf.variable_scope(\\\"Generatoe\\\"):\\n          # Generator\\n          generator = Sequential()\\n          generator.add(Dense(128*7*7, input_dim=self.randomDim, kernel_initializer=initializers.RandomNormal(stddev=0.02)))\\n          generator.add(LeakyReLU(0.2))\\n          generator.add(Reshape((128,7, 7)))\\n         ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create a subset of the dataset\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsong_df = song_df.head(10000)\\n\\n#Merge song title and artist_name columns to make a merged column\\nsong_df['song'] = song_df['title'].map(str) + \\\" - \\\" + song_df['artist_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 \\\"2.1\\/tutorials\\/requiv_crit_contact.ipynb\\\".\\nThe first task is:\\nContact Systems\\nContact systems are created by passing contact_binary=True to phoebe.default_binary() or by manually adding an envelope and setting the hierarchy correctly.\\nBy default, requiv@primary is the free Parameter, with requiv@secondary, pot@contact_envelope, and fillout_factor@contact_envelope constrained such that there is one single surface defining the envelope.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint b.filter(qualifier=['requiv', 'pot', 'fillout_factor'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Feature columns.\\n# - age\\n# - sex\\n# - ca        number of major vessels (0-3) colored by flourosopy\\n# - thal      3 = normal; 6 = fixed defect; 7 = reversable defect\\nfeature_columns = [\\n    fc.numeric_column('age', default_value=-1),\\n    fc.categorical_column_with_vocabulary_list('sex', [0, 1]),\\n    fc.numeric_column('ca'),\\n    fc.categorical_column_with_vocabulary_list(\\n        'thal', ['normal', 'fixed', 'reversible']),\\n]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFeature Columns\\nAs for any other TF estimator, data needs to be passed to the estimator, which is typically via an input_fn and parsed using FeatureColumns.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"By definition, a Graph is a collection of nodes (vertices) along with identified pairs of nodes (called edges, links, etc). In NetworkX, nodes can be any hashable object e.g. a text string, an image, an XML object, another Graph, a customized node object, etc. (Note: Python's None object should not be used as a node as it determines whether optional function arguments have been assigned in many functions.)\\nNodes\\nThe graph G can be grown in several ways. NetworkX includes many graph generator functions and facilities to read and write graphs in many formats. To get started, we'll look at simple manipulations. You can add one node at a time,\\n\",\"targets\":\"G.add_node(1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"04-lista manipulálás\\n\\naz alábbi cellában definiált kicsi lista segítségével építs egy olyan listát ami háromszor egymás után fordított sorrendben tartalmazza a kicsi lista elemeit.\\népíts egy olyan listát, ami 6 elemű, az első 5 eleme az eredeti kicsi lista elemei a 6. eleme pedig maga a kicsi lista.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nkicsi=['al',9,'+',42.137,'szoveg',69,1j]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<div class=\\\"alert alert-success\\\">\\n\\n<b>EXERCISE<\\/b>: The evolution of the yearly averages with, and the overall mean of all stations\\n\\n <ul>\\n  <li>Use `resample` and `plot` to plot the yearly averages for the different stations.<\\/li>\\n  <li>The overall mean of all stations can be calculated by taking the mean of the different columns (`.mean(axis=1)`).<\\/li>\\n<\\/ul>\\n<\\/div>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# %load snippets\\/02-pandas_introduction97.py\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2 - For three stocks of your choosing, put their symbols into a list and use pandas to retrieve their data from google for the time frame you created in part (1).  Print the results.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport pandas_datareader.data as web\",\"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.2\\/tutorials\\/constraints.ipynb\\\".\\nThe first task is:\\nEven though under-the-hood the constraints are being rebuilt from scratch, they will remember if you have flipped them to solve for some other parameter.\\nTo show this, let's flip the constraint for the secondary mass to solve for 'period' and then change the hierarchy back to its original value.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(\\\"M1: {}, M2: {}, period: {}, q: {}\\\".format(b.get_value('mass@primary@component'),\\n                                                 b.get_value('mass@secondary@component'),\\n                                                 b.get_value('period@binary@component'),\\n                                                 b.get_value('q@binary@component')))\\n\\nb.flip_constraint('mass@secondary@constraint', 'period')\\n\\nprint(\\\"M1: {}, M2: {}, period: {}, q: {}\\\".format(b.get_value('mass@primary@component'),\\n                                                 b.get_value('mass@secondary@component'),\\n                                                 b.get_value('period@binary@component'),\\n                                                 b.get_value('q@binary@component')))\\n\\nb.set_value('mass@secondary@component', 1.0)\\n\\nprint(\\\"M1: {}, M2: {}, period: {}, q: {}\\\".format(b.get_value('mass@primary@component'),\\n                                                 b.get_value('mass@secondary@component'),\\n                                                 b.get_value('period@binary@component'),\\n                                                 b.get_value('q@binary@component')))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Conclusion: F460M and F480M provide the best contrast for medium band filters across all masses and ages considered (1-100 Myr, 0.5-10 MJup).\\nLinder Models for Wide Band Filters\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfig, axes_all = plt.subplots(3,3,figsize=(14,9),sharex=True)\\n\\nages = [1, 10, 100] # Myr\\nmass_min, mass_max = (0.1, 10)  # MJup\\nmasses = np.logspace(np.log10(mass_min),np.log10(mass_max),num=30)\\nfilters = ['F277W', 'F356W', 'F444W']\\n\\n# Normalize a G2V star to it's K-Band absolute magnitude\\nbp_k = pynrc.bp_2mass('k')\\nspt = 'G2V'\\nsp_star = pynrc.stellar_spectrum(spt, 3.2, 'vegamag', bp_k)\\n\\nmodel = 'linder'\\n\\nfor i, age in enumerate(ages):\\n    axes = axes_all[i]\\n    \\n    for filt in filters:\\n        bp = nrc_utils.read_filter(filt, module='B')\\n\\n        res = get_planet_counts(bp, age, masses, return_mags=False, model=model)    \\n        axes[0].loglog(masses, res, marker='.', label=filt)\\n\\n        res = get_planet_counts(bp, age, masses, return_mags=True, model=model)\\n        axes[1].semilogx(masses, res, marker='.', label=filt)\\n\\n        obs = S.Observation(sp_star, bp, bp.wave)\\n        axes[2].semilogx(masses, res - obs.effstim('vegamag'), marker='.', label=filt)\\n\\n    axes[0].set_ylabel(\\\"Flux (counts\\/sec)\\\")\\n    axes[1].set_ylabel(\\\"Flux (mag)\\\")\\n    axes[2].set_ylabel(\\\"Contrast (mag)\\\")\\n    if i==0: \\n        axes[0].set_title(f\\\"Companion Flux (counts)\\\")\\n        axes[1].set_title(f\\\"Companion Flux (mags)\\\")\\n        axes[2].set_title(f\\\"Contrast Relative to {spt} Primary\\\")\\n\\n    \\n    for j, ax in enumerate(axes):\\n        if j>0:\\n            ax.set_ylim(ax.get_ylim()[::-1])\\n        ax.legend(title=f'Age = {age} Myr', loc='lower right')\\n        if i==2: \\n            ax.set_xlabel('Companion Mass ($M_{Jup}$)')\\n            \\n            \\nmod_str = 'BEX' if model=='linder' else 'COND'\\nfig.suptitle(f'{mod_str} Models', fontsize=15)\\n    \\nfig.tight_layout()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"06-Diverse-pyradi-utilities.ipynb\\\".\\nThe first task is:\\nReading two-dimensional lookup tables\\nThe ryfiles.read2DLookupTable\\nReads a 2D lookup table and extract the data. The table has the following format:\\nline 1: xlabel ylabel title\\nline 2: 0 (vector of y (col) abscissa)\\nlines 3 and following: (element of x (row) abscissa), followed\\nby table data.\\n\\nFrom line\\/row 3 onwards the first element is the x abscissa value\\nfollowed by the row of data, one point for each y abscissa value.\\nThe file format can depicted as follows:\\nx-name y-name ordinates-name\\n0 y1 y2 y3 y4\\nx1 v11 v12 v13 v14\\nx2 v21 v22 v23 v24\\nx3 v31 v32 v33 v34\\nx4 v41 v42 v43 v44\\nx5 v51 v52 v53 v54\\nx6 v61 v62 v63 v64\\n\\nThe function has the signature:\\n`read2DLookupTable(filename)`\\n\\n\\nfname (string) input path and filename    \\n\\nThe function returns the following:\\n\\nxVec ((np.array[N])) x abscissae\\nyVec ((np.array[M])) y abscissae\\ndata ((np.array[N,M])) data corresponding the x,y\\nxlabel (string) x abscissa label\\nylabel (string) y abscissa label\\ntitle (string) dataset title\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfilecont = ['x-name y-name ordinates-name\\\\n',\\n'0 1   2   3  4\\\\n',\\n'10 11 12 13 14\\\\n',\\n'20 21 22 23 24\\\\n',\\n'30 31 32 33 34\\\\n',\\n'40 41 42 43 44\\\\n',\\n'50 51 52 53 54\\\\n',\\n'60 61 62 63 64\\\\n']\\n\\nwith open('2dfile.dat', 'wt') as f:\\n    f.writelines(filecont)\\n\\nimport os.path    \\nif os.path.sep == '\\/':\\n    !cat 2dfile.dat\\nelse:\\n    !type 2dfile.dat    \\n    \\nxVec,yVec,data,xlabel, ylabel, title = ryfiles.read2DLookupTable('2dfile.dat')\\nprint('\\\\n')\\nprint('xVec={}'.format(xVec))\\nprint('yVec={}'.format(yVec))\\nprint('data={}'.format(data))\\nprint('xlabel={}'.format(xlabel))\\nprint('ylabel={}'.format(ylabel))\\nprint('title={}'.format(title))\",\"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\\/HNSCC_MATH.ipynb\\\".\\nThe first task is:\\nFrom another angle, I don't see the HPV effect in my data.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndraw_survival_curves(math_t, surv, hpv)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Creating and Using a Rule-Based Matcher\\nThis, typically involves the following steps:\\n1. Creating the rule-based matcher\\n2. Creating features\\n3. Adding Rules\\n4. Using the Matcher to Predict Results\\nCreating the Rule-Based Matcher\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nbrm = em.BooleanRuleMatcher()\",\"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+Project+Euler.ipynb\\\".\\nThe first task is:\\nProblem 6\\nThe sum of the squares of the first ten natural numbers is,\\n12 + 22 + ... + 102 = 385\\nThe square of the sum of the first ten natural numbers is,\\n(1 + 2 + ... + 10)2 = 552 = 3025\\nHence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.\\nFind the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#Define the range of numbers we are going to check\\nr = range(1, 101)  \\na = sum(r)\\n\\n#Multipy the sum of the number and subtract the suqae of the sum of the numbers\\n\\nprint (a * a - sum(i*i for i in 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 \\\"Lectures\\/Lecture_2\\/Jupyter_notebook_sheets\\/random_module.ipynb\\\".\\nThe first task is:\\nGiven $\\\\mu\\\\in[0,2\\\\pi)$ and $\\\\kappa>0$, the density function of the von Mises (or circular normal, or Tikhonov) distribution of parameters $\\\\mu$ and $\\\\kappa$, defined over $[0,2\\\\pi]$, is equal to $\\\\frac{e^{\\\\kappa\\\\cos(x-\\\\mu)}}{2\\\\pi\\\\Sigma_{m=0}^\\\\infty\\\\frac{1}{m!\\\\Gamma(m+\\\\alpha+1)}(\\\\frac{x}{2})^{2m+\\\\alpha}}$. It is illustrated with $\\\\mu=\\\\pi$ and $\\\\kappa=4$.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%matplotlib inline\\nfrom matplotlib.pyplot import hist, xlim, gca\\nfrom matplotlib.ticker import FuncFormatter\\n\\nfrom random import vonmisesvariate\\nfrom math import pi\\n\\nnb_of_values = 100000\\ngenerated_values = []\\nfor i in range(nb_of_values):\\n    generated_values.append(vonmisesvariate(pi, 4))\\n    \\ndef to_percent(x, _):\\n    return str(x \\/ nb_of_values * 100) + '%'\\n\\nxlim(0, 2 * pi)\\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\":\"A word about TensorFlow model serving\\nExporting an inference graph and the serving signature is \\\"simple\\\" (though the serving_fn interface could be improved). The cool thing is that once you have your tf.estimator and your serving_input_fn, you can just use tensorflow_serving and get a RESTful API serving your model!\\nServing interface\\n\",\"targets\":\"def serving_input_fn():\\n    tokens = tf.placeholder(\\n        dtype=tf.int32, shape=[None, None], name=\\\"tokens\\\")\\n    sequence_length = tf.size(tokens)\\n    features = {'tokens': tokens, 'sequence_length': sequence_length}\\n    return tf.estimator.export.ServingInputReceiver(\\n        features=features, receiver_tensors=tokens)\\n\\nestimator.export_savedmodel('export', serving_input_fn)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"B\\nWrite a function that computes the remainder of two numbers.\\n\\nnamed remainder\\ntakes 2 arguments, two numbers x and y\\nreturns 1 number, the remainder of x (the first argument) divided by y (the second argument)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport numpy as np\\nnp.testing.assert_allclose(0.0, remainder(100, 2))\\nnp.testing.assert_allclose(6.0, remainder(123, 39))\\nnp.testing.assert_allclose(3.0, remainder(987, 4))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# YOUR CODE HERE\\nfrom scipy.interpolate import interp2d \\n\\nxnew=np.linspace(-5,5,100)\\nynew=np.linspace(-5,5,100)\\n\\nXnew, Ynew = np.meshgrid(xnew,ynew)\\n\\nFnew=griddata((x,y),f,(Xnew,Ynew),method='cubic')\\n\\n\\n\\nassert xnew.shape==(100,)\\nassert ynew.shape==(100,)\\nassert Xnew.shape==(100,100)\\nassert Ynew.shape==(100,100)\\nassert Fnew.shape==(100,100)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\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.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2.4) Dilate footprint to provide a window or region for the point source.\\nWe will use this window to compute the centroid and total flux of the star in the next two lessons. In the meantime, compute the flux like we did in introductionToStellarPhotometry assuming the input center.\\n\",\"targets\":\"# complete\\ngrowBy = fwhm\\nmask = detection_image > threshold_value\\nprint(np.count_nonzero(mask))\\ndilated_mask = scipy.ndimage.binary_dilation(mask, iterations=growBy)\\nprint(np.count_nonzero(dilated_mask))\\n\\nfig, ax = pixel_plot(x[dilated_mask], image[dilated_mask])\\n\\n# easy aperture flux:\\nnp.sum(image[dilated_mask])\\n\\n# Copied from solutions of previous notebook\\n\\nfrom scipy.optimize import minimize\\n\\npsf = phi(x[dilated_mask], mu=35, fwhm=5)\\nim = image[dilated_mask]\\n\\n# minimize the square of the residuals to determine flux\\ndef sum_res(A, flux=im, model=psf):\\n    return sum((flux - A*model)**2)\\n\\nsim_star = simulate(x, mu, fwhm, S, F)\\npsf_flux = minimize(sum_res, 300, args=(im, psf))\\n\\nprint(\\\"The PSF flux is {:.3f}\\\".format(psf_flux.x[0]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<table>\\n    <tr>\\n        <td><center>15 Collision Hotspots of Manhattan<\\/center><\\/td>\\n    <\\/tr>\\n    <tr>\\n        <td><img src=\\\"images\\/kmeans_1.jpg\\\" alt=\\\"Drawing\\\" style=\\\"width: 350px;\\\"\\/> <\\/td>\\n    <\\/tr>\\n<\\/table>\\n\\nYou can observe that a small area between the 25th and 60th Streets, the Midtown Manhattan area, has as many collision hotspots as the northern part of Manhattan, including uptown Manhattan area, and twice as many collision hotspots as Lower Manhattan. This is an interesting result that suggests just how many more collisions happen Midtown compared to the rest of Manhattan.\\nWe can focus on parts of New York City to get a more granular understanding of problematic areas. Let's take Midtown Manhattan, for example. We can run kmeans only on the collisions that occur in Midtown Manhattan and plot them. To (roughly) get the collisions in Midtown Manhattan, we can define and use a function to return the collisions that are in a circle:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef get_collisions_in_circle(collisions, latitude, longitude, radius_miles):\\n    location_data = collisions.loc[:, ['LATITUDE', 'LONGITUDE']]\\n    center = np.array([latitude, longitude])\\n    # Calculate distances of each collision to the center\\n    distances = location_data.apply(lambda x: distance((x['LATITUDE'], x['LONGITUDE']), center).miles, axis = 1)\\n    # Return the collisions inside the circle\\n    return collisions[distances <= radius].reset_index(drop=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"1 Specialized libraries\\nSpecialized libraries, which provide efficient compiled implementations of the heavy computations, is an easy way to solve the performance problem. That is for example NumPy, which uses efficient BLAS and LAPACK implementations as a backend. SciPy and scikit-learn fall in the same category.\\nImplement below the accuracy function using:\\n1. Only functions provided by NumPy. The idea here is to vectorize the computation.\\n2. The implementation of scikit-learn, our machine learning library.\\nThen test that it provides the correct result and measure it's execution time. How much faster are they compared to the pure Python implementation ?\\n\",\"targets\":\"def accuracy_numpy(y_pred, y_true):\\n    \\\"\\\"\\\"Numpy implementation.\\\"\\\"\\\"\\n    # Your code here.\\n    return 0\\n\\ndef accuracy_sklearn(y_pred, y_true):\\n    \\\"\\\"\\\"Scikit-learn implementation.\\\"\\\"\\\"\\n    # Your code here.\\n    return 0\\n\\n# assert np.allclose(accuracy_numpy(y_pred, y_true), accuracy_python(y_pred, y_true))\\n# assert np.allclose(accuracy_sklearn(y_pred, y_true), accuracy_python(y_pred, y_true))\\n\\n# %timeit accuracy_numpy(y_pred, y_true)\\n# %timeit accuracy_sklearn(y_pred, y_true)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# build a model specifying the MLP model with hyperband\\nmodel_mlp = ModelPipeline(model='multilayer_perceptron_classifier',\\n                          model_name='MLP example',\\n                          primary_key='UNITID',\\n                          dependent_variable=['CONTROL'],\\n                          cross_validation_parameters='hyperband',\\n                          etl=etl\\n                          )\\ntrain_mlp = model_mlp.train(train_data, \\n                            n_jobs=10) # parallel hyperparameter optimization and validation!\\n# block until the job finishes\\ntrain_mlp.result()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nHyperparameter optimization with Hyperband and Neural Networks\\nMultilayer Perceptrons (MLPs) are simple neural networks, which are now built in to CivisML. The MLP estimators in CivisML come from muffnn, another open source package written and maintained by Civis Analytics using tensorflow. Let's fit one using hyperband.\\nTuning hyperparameters is a critical chore for getting an algorithm to perform at its best, but it can take a long time to run. Using CivisML 2.0, we can use hyperband as an alternative to conventional grid search for hyperparameter optimization-- it runs about twice as fast. While grid search runs every parameter combination for the full time, hyperband runs many combinations for a short time, then filters out the best, runs them for longer, filters again, and so on. This means that you can try more combinations in less time, so we recommend using it whenever possible. The hyperband estimator is open source and available on GitHub. You can learn about the details in the original paper, Li et al. (2016).\\nRight now, hyperband is implemented in CivisML named preset models for the following algorithms: \\n- Multilayer Perceptrons (MLPs)\\n- Stacking\\n- Random forests\\n- GBTs\\n- ExtraTrees\\nUnlike grid search, you don't need to specify values to search over. If you pass cross_validation_parameters='hyperband' to ModelPipeline, hyperparameter combinations will be randomly drawn from preset distributions.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"CS231n\\/assignment1\\/two_layer_net.ipynb\\\".\\nThe first task is:\\nBackward pass\\nImplement the rest of the function. This will compute the gradient of the loss with respect to the variables W1, b1, W2, and b2. Now that you (hopefully!) have a correctly implemented forward pass, you can debug your backward pass using a numeric gradient check:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom cs231n.gradient_check import eval_numerical_gradient\\n\\n# Use numeric gradient checking to check your implementation of the backward pass.\\n# If your implementation is correct, the difference between the numeric and\\n# analytic gradients should be less than 1e-8 for each of W1, W2, b1, and b2.\\n\\nloss, grads = net.loss(X, y, reg=0.1)\\n\\n# these should all be less than 1e-8 or so\\nfor param_name in grads:\\n  f = lambda W: net.loss(X, y, reg=0.1)[0]\\n  param_grad_num = eval_numerical_gradient(f, net.params[param_name], verbose=True)\\n  print '%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"01-Fundamentals.ipynb\\\".\\nThe first task is:\\nWe now solve for $\\\\boldsymbol{A} \\\\boldsymbol{x}=  \\\\boldsymbol{b}$ and $\\\\boldsymbol{A} (\\\\boldsymbol{x}+ \\\\delta \\\\boldsymbol{x}) = \\\\boldsymbol{b} + \\\\delta \\\\boldsymbol{b}$:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nx  = np.linalg.solve(H, b)\\nx1 = np.linalg.solve(H, b1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<b> <font color=red>NOTE<\\/font>: to shorten the output of the next command, click the leftmost mouse button on the left of the output to activate a scrolling window. Do the same to anyother help output which follows after this one <\\/b>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndir(scores)\\n\\nxmean = scipy.mean(scores)\\nsigma = scipy.std(scores)\\nn = scipy.size(scores)\\nprint (\\\"({0:0.14f}, {1:0.15f}, {2:0.14f})\\\".format(xmean, xmean - 2.576*sigma\\/scipy.sqrt(n), \\n                                                  xmean + 2.576*sigma\\/scipy.sqrt(n) ))\\n\\n\\nfrom scipy import stats\\nresult=scipy.stats.bayes_mvs(scores)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# DATASET 1 CLASSIFIER CODE GOES HERE\\n\\n# DATASET 2 CLASSIFIER CODE GOES HERE\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTrain your classifiers\\nNext you need to copy\\/paste in the code from your ML-4 Homework to train your classifiers on the data. Because we're using exactly the same data and you set a random seed, we can expect to get the same classifiers.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"(2b) Root mean squared error \\nWe naturally would like to see how well this naive baseline performs.  We will use root mean squared error (RMSE) for evaluation purposes.  Implement a function to compute RMSE given an RDD of (label, prediction) tuples, and test out this function on an example.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n # TODO: Replace <FILL IN> with appropriate code\\ndef squaredError(label, prediction):\\n    \\\"\\\"\\\"Calculates the the squared error for a single prediction.\\n\\n    Args:\\n        label (float): The correct value for this observation.\\n        prediction (float): The predicted value for this observation.\\n\\n    Returns:\\n        float: The difference between the `label` and `prediction` squared.\\n    \\\"\\\"\\\"\\n    return np.power(label - prediction, 2)\\n\\ndef calcRMSE(labelsAndPreds):\\n    \\\"\\\"\\\"Calculates the root mean squared error for an `RDD` of (label, prediction) tuples.\\n\\n    Args:\\n        labelsAndPred (RDD of (float, float)): An `RDD` consisting of (label, prediction) tuples.\\n\\n    Returns:\\n        float: The square root of the mean of the squared errors.\\n    \\\"\\\"\\\"\\n    return np.sqrt(1.0 \\/ labelsAndPreds.count() * labelsAndPreds.map(lambda (x, y): squaredError(x, y)).reduce(lambda x, y: x+y))\\n\\nlabelsAndPreds = sc.parallelize([(3., 1.), (1., 2.), (2., 2.)])\\n# RMSE = sqrt[((3-1)^2 + (1-2)^2 + (2-2)^2) \\/ 3] = 1.291\\nexampleRMSE = calcRMSE(labelsAndPreds)\\nprint exampleRMSE\\n\\n# TEST Root mean squared error (2b)\\nTest.assertTrue(np.allclose(squaredError(3, 1), 4.), 'incorrect definition of squaredError')\\nTest.assertTrue(np.allclose(exampleRMSE, 1.29099444874), 'incorrect value for exampleRMSE')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"6. Family simulation (5pts)\\nUse a simulation to determine the average number of children in a family if all families had children until they had a girl (and then stopped). Assume equal probability of girls and boys and use a random generator to simulate each birth. Simulate 10,000 families and output the average number of children they had. Your answer should be close to 2.\\nNote: I'm purposely not giving any step by step instructions here because I'd like you to practice translating a word problem into code. It may help if you try break down the problem into smaller parts first. For example, see if you can simulate just one family first, then once that's working, add code to make it run through 10,000 families. Alternatively, you might feel more comfortable writing code to print \\\"hi\\\" 10,000 times, and then replace \\\"print hi\\\" with code for simulating each family. Do whatever makes the problem feel more manageable to you. Learning to break down big problems into smaller parts like this is an essential skill for programming, so I encourage you to work through this. If you get it, then I think it's safe to say you've mastered the material in this lesson and are well on your way to becoming a true programmer!\\nI'll give partial credit for good efforts!\\n\",\"targets\":\"import random\\n\\n# By convention, variables with a set, pre-defined value (\\\"constants\\\")\\n# are indicated by ALL_CAPS variable names and are defined at the top.\\n# It's not really necessary to define GIRL = 1, but it will make\\n# the code easier to read and understand, so it's considered good form.\\nNUM_FAMS = 10000 \\nGIRL = 1\\n\\n# regular variables, like this counter, are lower case\\/camelCase\\ntotalKidsAllFams = 0\\n\\nfor i in range(NUM_FAMS):\\n    numKids = 0\\n    hadGirl = False\\n\\n    while not hadGirl:\\n        numKids = numKids + 1\\n        gender = random.randint(0,1) #the miracle of birth\\n        if gender == GIRL:\\n            hadGirl = True\\n        \\n    # once we exit the while loop, we must have had a girl.\\n    # so add the number of kids this fam had to the running total, and\\n    # move on to the next family\\n    totalKidsAllFams = totalKidsAllFams + numKids\\n\\n# finally, divide the total number of kids by the number of families to get the avg\\nprint \\\"Avg kids per fam:\\\", float(totalKidsAllFams) \\/ NUM_FAMS\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Converting blast .srl to .csv\\n\",\"targets\":\"!cd $blastDir; \\\\\\n    CLdb -- arrayBlast -- srl2csv \\\\\\n    spacers_cut1_blastn_filt.srl \\\\\\n    > spacers_cut1_blastn_filt.txt\\n    \\n# assessing table of blast hits    \\n!cd $blastDir; \\\\\\n    head spacers_cut1_blastn_filt.txt\\n\\n#!printf \\\"Number of blast hits: \\\"\\nnhits = !cd $blastDir; wc -l spacers_cut1_blastn_filt.txt\\nnhits = nhits[0].split(' ')[0]\\nprint \\\"Number of blast hits: {}\\\".format(int(nhits) - 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 \\\"2.3\\/tutorials\\/logg.ipynb\\\".\\nThe first task is:\\nRelevant Parameters\\nThe 'logg' parameter defines the stellar surface gravity at requiv and is constrained by default.\\nIMPORTANT NOTE: as the logg parameter is defined to be the surface gravity given the value of mass and requiv, it may not be appropriate to compare or fix the value from an \\\"observed\\\" value of logg (from a spectrum, for example).\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(b.filter('logg', context='component'))\\n\\nprint(b.filter('logg', context='constraint'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"9. Adaptive learning rate\\n\\nexponential_decay\\nconsine_decay\\nlinear_cosine_decay\\nconsine_decay_restarts\\npolynomial decay\\npiecewise_constant_decay\\n\",\"targets\":\"def create_estimator(params, run_config):\\n  \\n  wide_columns, deep_columns = create_feature_columns()\\n  \\n  def _update_optimizer(initial_learning_rate, decay_steps):\\n    \\n    # learning_rate = tf.train.exponential_decay(\\n    #   initial_learning_rate,\\n    #   global_step=tf.train.get_global_step(),\\n    #   decay_steps=decay_steps,\\n    #   decay_rate=0.9\\n    # )\\n\\n    learning_rate = tf.train.cosine_decay_restarts(\\n      initial_learning_rate,\\n      tf.train.get_global_step(),\\n      first_decay_steps=50,\\n      t_mul=2.0,\\n      m_mul=1.0,\\n      alpha=0.0,\\n    )\\n\\n    tf.summary.scalar('learning_rate', learning_rate)\\n\\n    return tf.train.AdamOptimizer(\\n      learning_rate=initial_learning_rate)\\n    \\n  estimator = tf.estimator.DNNLinearCombinedClassifier(\\n\\n    n_classes=len(TARGET_LABELS),\\n    label_vocabulary=TARGET_LABELS,\\n    weight_column=WEIGHT_COLUMN_NAME,\\n\\n    dnn_feature_columns=deep_columns,\\n    dnn_optimizer=lambda: _update_optimizer(params.learning_rate, params.max_steps),\\n    dnn_hidden_units=params.hidden_units,\\n    dnn_dropout=params.dropout,\\n    batch_norm=True,\\n    \\n    linear_feature_columns=wide_columns,\\n    linear_optimizer='Ftrl',\\n    \\n    config=run_config\\n  )\\n  \\n  return estimator\\n\\nparams.learning_rate = 0.1\\nparams.max_steps = 1000\\nrun_config = tf.estimator.RunConfig(\\n    tf_random_seed=RANDOM_SEED,\\n    save_checkpoints_steps=200,\\n    model_dir=model_dir,\\n)\\n\\nif COLAB:\\n  from tensorboardcolab import *\\n  TensorBoardColab(graph_path=model_dir)\\n\\nestimator = create_estimator(params, run_config)\\nrun_experiment(estimator, params, run_config)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Housing Prices.ipynb\\\".\\nThe first task is:\\nFeature Selection using Lasso\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#Feature Selection using Lasso\\n\\nplt.figure(figsize=(20, 5))\\nsns.set_style(\\\"whitegrid\\\")\\n\\nplt.subplot(1, 4, 1)\\nfor lambd in [x * 0.01 for x in range(1, 100)]:\\n    lasso = Lasso(alpha=lambd)\\n    lasso_coef = lasso.fit(X0, Y).coef_\\n    plt.xticks(range(len(names)), names, rotation=90)\\n    plt.ylabel('Coefficients')\\n    plt.plot(range(len(names)), lasso_coef)\\n    plt.title('Lasso (All features)')\\n\\nplt.subplot(1, 4, 2)\\nfor lambd in [x * 0.01 for x in range(1, 100)]:\\n    lasso = Lasso(alpha=lambd)\\n    lasso_coef = lasso.fit(XRFE, Y).coef_\\n    plt.xticks(range(len(namesRFE)), namesRFE, rotation=90)\\n    plt.ylabel('Coefficients')\\n    plt.plot(range(len(namesRFE)), lasso_coef)\\n    plt.title('Lasso RFE')\\n\\nplt.subplot(1, 4, 3)    \\nfor lambd in [x * 0.01 for x in range(1, 100)]:\\n    lasso = Lasso(alpha=lambd)\\n    lasso_coef = lasso.fit(XBS, Y).coef_\\n    plt.xticks(range(len(namesBS)), namesBS, rotation=90)\\n    plt.ylabel('Coefficients')\\n    plt.plot(range(len(namesBS)), lasso_coef)\\n    plt.title('Lasso (Best Selector)')\\n    \\nplt.subplot(1, 4, 4)\\nfor lambd in [x * 0.01 for x in range(1, 100)]:\\n    lasso = Lasso(alpha=lambd)\\n    lasso_coef = lasso.fit(XFIRF, Y).coef_\\n    plt.xticks(range(len(namesFIRF)), namesFIRF, rotation=90)\\n    plt.ylabel('Coefficients')\\n    plt.plot(range(len(namesFIRF)), lasso_coef)\\n    plt.title('Lasso on Random Forest')\\n    \\nplt.tight_layout()\\nplt.show()\\n\\n#New set of features based on results obtained in with Lasso, Random Forest and RFE\\n\\nXl = X1[['Rooms', 'BuildingArea', 'Regionname','Distance', 'Neighbourhood']]\\n\\n#Split the data into training and testing datasets. Split: 70\\/30; train\\/test\\n\\nX_train, X_test, y_train, y_test = train_test_split(Xl,Y, test_size=0.3, random_state=0)\\n\\n#Initiating the cross validation generator, N splits = 5\\nkf = KFold(5)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"%%cython_pyximport magična funkcija služi da se unese proizvoljan Cython kod u IPython notebook ćeliju. Taj kod se sprema u .pyx u radnom direktoriju i onda importira koristeći pyximport. Moramo specificirati ime modula (u donjem slučaju foo). Svi objekti modula se automatski importiraju.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%%cython_pyximport foo\\ndef f(x):\\n    return 4.0*x\\n\\nf(10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"An example solution from our reference model, at high resolution:\\n\",\"targets\":\"reference.y[0].sel(time=slice(10, 60)).plot.imshow()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"And a final check to make this newly defined LFC log only has values within the range 1 to 4 (there will be no undefined samples in this particular depth interval, i.e. classes with LFC=0):\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint(\\\"LFC min: {0}, LFC max: {1}\\\".format(logs.LFC.min(), logs.LFC.max()))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create a class with Inheritance\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nclass Teacher(Human):\\n    ''' Teacher of Python '''\\n\\n    def give_lecture(self):\\n        ''' Print lecture on the screen ''' \\n        \\n        print ('bla bla bla')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<a id='num_mod_sev'><\\/a>\\nNumber of Moderate Severe Symptoms\\n\\nIn this analysis, we create an indicator variable for moderate\\/severe for the following 5 symptoms:\\n    - Pain\\n    - Dyspnea\\n    - Fatigue\\n    - Anxiety\\n    - Constipation\\nWe start by first create a yes\\/no variable for each symptom. For instance, for pain, if the symptom score is [5,10], then a '1' is coded, else a '0' is coded (this includes things like <5, a 994 code which indicates unable to ascertain, as well as missing values). If any of this needs to be changed let me know. Once created, we then create 3 new variables which look to determin how many of the symptoms are moderate or severe. What follows is a summary of findings.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n#first read in the (summary) data\\nimport pandas as pd\\nsumm = pd.read_csv(open(\\\".\\/python_scripts\\/14_number_of_modsev_symptoms.csv\\\",\\\"r\\\"))\\n#now print those with '1 or more moderate\\/severe symptoms'\\nsumm[0:2]\\n\\n#now print those with '2 or more moderate\\/severe symptoms'\\nsumm[2:4]\\n\\n#now print those with '3 or more moderate\\/severe symptoms'\\nsumm[4:6]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"IoT_Camera.ipynb\\\".\\nThe first task is:\\nGRAVANT UN VIDEO\\nCan you write Python code for it?\\n\",\"targets\":\"\\ncamera.start_preview()\\ncamera.start_recording('\\/home\\/pi\\/video.h264')\\nsleep(10)\\ncamera.stop_recording()\\ncamera.stop_preview()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Calculate GLCM Features\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nglcmFeatures = glcm.RadiomicsGLCM(croppedImage, croppedMask, **settings)\\n\\n# Set the features to be calculated\\n# glcmFeatures.enableFeatureByName('SumEntropy', True)\\nglcmFeatures.enableAllFeatures()\\n\\n# Print out the docstrings of the enabled features\\nprint('Will calculate the following GLCM features: ')\\nfor f in glcmFeatures.enabledFeatures.keys():\\n  print(f)\\n  print(getattr(glcmFeatures, 'get%sFeatureValue' % f).__doc__)\\n\\n# Calculate the features and print(out result)\\nprint('Calculating GLCM features...',)\\nresult = glcmFeatures.execute()\\nprint('done')\\n\\nprint('Calculated GLCM features: ')\\nfor (key, val) in six.iteritems(result):\\n  print('  ', key, ':', val)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<ol start=\\\"8\\\">\\n  <h4><li> Comparez la réponse au gros bloc, avec le double de la réponse au petit bloc, en faisant un graphe de la différence des deux signaux.<\\/li><\\/h4>\\n<\\/ol>\\n\",\"targets\":\"%%matlab\\nbloc_conv2 = conv(bloc2,noyau,'same');\\nplot(time_samples,bloc_conv-bloc_conv2,'b-o')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Conditioning the data set\\nNow we extract just the feature variables we need to perform the classification.  The predictor variables are the five wireline values and two geologic constraining variables. We also get a vector of the facies labels that correspond to each feature vector.\\n\",\"targets\":\"correct_facies_labels = training_data['Facies'].values\\n\\n# dropping certain labels and only keeping the geophysical log values to train on\\nfeature_vectors = training_data.drop(['Formation', 'Well Name', 'Depth','Facies','FaciesLabels'], axis=1)\\nfeature_vectors.describe()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"A simple text-processing function, and baseline speed test\\nThe function I'll be testing is a simple text-processing function for tokenizing a string - returning the string as a list of words, after doing a bit of preprocessing.\\n\",\"targets\":\"import re\\nfrom nltk.corpus import stopwords\\n\\ndef tokenize(text):\\n    ''' Accept a string, return list of words (lowercased) without punctuation or stopwords'''\\n\\n    # lowercase everything\\n    text = text.lower()\\n    \\n    # remove punctuation (\\\\W matches any non-alphanumeric character)\\n    text = re.sub(\\\"\\\\W\\\", \\\" \\\", text)\\n    \\n    # return list of words, without stopwords (stopwords are very common words which may not convey much info)\\n    droplist = stopwords.words('english')\\n    \\n    return [word for word in text.split() if word not in droplist]\\n    \\ntokenize('This is a sentence. And another one with punctuation and special characters to strip!?*&^%')\",\"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.atmoschem.key_properties.timestep_framework.split_operator_advection_timestep')  \\n\\n# PROPERTY VALUE: \\n# Set as follows: DOC.set_value(value)  \\nDOC.set_value(30) \\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n3.2. Split Operator Advection Timestep\\nIs Required: FALSE&nbsp;&nbsp;&nbsp;&nbsp;Type: INTEGER&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 0.1\\nTimestep for chemical species advection (in seconds)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2.Mache dasselbe mit einer Liste aus 100 Elementen und ordne sie der Variabel b zu.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nlist(range(100))\\n\\nb = list(range(100))\\n\\nb\",\"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._Clustering_Hierarquico_Microarray.ipynb\\\".\\nThe first task is:\\nExibição de um dendograma\\nFunção que, para um índice $i$, devolve o nome do gene:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nllf = lambda id : genes[id]\\n\\nplt.figure(figsize=(12, 30))\\nplt.title('Dendrograma')\\nplt.ylabel('Gene')\\nplt.xlabel(u'Distância (Ward)')\\nden = dendrogram(Z, orientation='left', leaf_font_size=9, leaf_label_func=llf)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"--- 2.2 . Además de definir las columnas, es necesario definir cuántos renglones tiene que ignorar el script antes de encontrar los encabezados. Estos renglones se definen a continuación en un diccionario:\\n\",\"targets\":\"skiprows = {\\n    '02' : 7,   # Tipo de piso\\n    '08' : 7,   # Combustible utilizado para cocinar\\n    '09' : 7,   # Utilizan leña o carbón para cocinar y distribucion porcentual segun disponibilidad de estufa o fogon \\n    '16' : 7,   # disponibilidad de energía eléctrica\\n    '19' : 7,   # Forma de eliminación de residuos\\n    '20' : 8,   # Viviendas que entregan sus residuos al servicio publico y distribucion porcentual por condición de separacion\\n    '21' : 7,   # Separación y reutilización de residuos\\n    '23' : 7,   # Disponibilidad y tipo de equipamiento\\n    '24' : 8,   # Disponibilidad de agua entubada según disponibilidad y acceso\\n    '25' : 7,   # Disponibilidad de agua entubada según fuente de abastecimiento\\n    '26' : 8,   # Disponibilidad de drenaje y lugar de desalojo\\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 \\\"Project\\/trained_mental_rotation_ens_inhibition.ipynb\\\".\\nThe first task is:\\nTesting\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntesting = np.dot(ONE,np.dot(label_weights,activity_to_img_weights))\\ntesting = output_acts[300]\\nplt.subplot(131)\\npylab.imshow(np.reshape(testing,(dim, dim), 'F').T, cmap=plt.get_cmap('Greys_r'))\\n\\n#Get image\\n#testing = np.dot(ONE,np.dot(label_weights,activity_to_img_weights))\\n#noise = np.random.random([28,28]).ravel()\\ntesting = node_func(0,testing)\\n\\nplt.subplot(132)\\npylab.imshow(np.reshape(testing,(dim, dim), 'F').T, cmap=plt.get_cmap('Greys_r'))\\n\\n\\n#Get activity of image\\n_, testing_act = nengo.utils.ensemble.tuning_curves(ens, sim, inputs=testing)\\n\\n#Get encoder outputs\\ntesting_filter = np.dot(testing_act,rotated_counter_after_encoder_weights_filter)\\n\\n#Get activities\\ntesting_filter = ens.neuron_type.rates(testing_filter, sim.data[ens].gain, sim.data[ens].bias)\\n\\nfor i in range(5):\\n    testing_filter = np.dot(testing_filter,rotated_counter_after_encoder_weights_filter)\\n    testing_filter = ens.neuron_type.rates(testing_filter, sim.data[ens].gain, sim.data[ens].bias)\\n    testing_filter = np.dot(testing_filter,activity_to_img_weights)\\n    testing_filter = node_func(0,testing_filter)\\n    _, testing_filter = nengo.utils.ensemble.tuning_curves(ens, sim, inputs=testing_filter)\\n\\n\\n#testing_rotate = np.dot(testing_rotate,rotation_weights)\\n\\ntesting_filter = np.dot(testing_filter,activity_to_img_weights)\\n\\nplt.subplot(133)\\npylab.imshow(np.reshape(testing_filter,(dim, dim), 'F').T, cmap=plt.get_cmap('Greys_r'))\\n\\nplt.show()\\n\\n\\nplt.subplot(121)\\npylab.imshow(np.reshape(X_train[0],(dim, dim), 'F').T, cmap=plt.get_cmap('Greys_r'))\\n\\n#Get activity of image\\n_, testing_act = nengo.utils.ensemble.tuning_curves(ens, sim, inputs=X_train[0])\\n\\ntesting_rotate = np.dot(testing_act,activity_to_img_weights)\\n\\nplt.subplot(122)\\npylab.imshow(np.reshape(testing_rotate,(dim, dim), 'F').T, cmap=plt.get_cmap('Greys_r'))\\n\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%tikz --size 600,400\\n\\\\tikzstyle{neuron}=[circle, draw, minimum size=2 cm,inner sep=5pt, node distance=2cm]\\n\\n\\\\node () at (0, 4.5) {$l$th layer};\\n\\\\node () at (4, 4.5) {$l+1$th layer};\\n\\\\node[neuron] (i1) at (0,  2) {l, k};\\n\\\\node[neuron] (i2) at (0, -2) {l, k+1};\\n\\\\node[neuron] (h11) at (4,  3) {l+1, j-1};\\n\\\\node[neuron] (h12) at (4,  0) {l+1, j};\\n\\\\node[neuron] (h13) at (4, -3) {l+1, j+1};\\n\\\\draw[->] (i1) -- (h11);\\n\\\\draw[->] (i2) -- (h11);\\n\\\\draw[->, line width=0.5mm] (i1) -- node[above=0.2] {$w^{l}_{j,k}$ } (h12);\\n\\\\draw[->] (i2) -- (h12);\\n\\\\draw[->] (i1) -- (h13);\\n\\\\draw[->] (i2) -- (h13);\\n#이거 코드는 무시\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<table style=\\\"display: inline-table; margin-right: 30pt;\\\">\\n<tbody><tr style=\\\"background:#def; text-align:center;\\\">\\n<td colspan=\\\"2\\\"><b>INPUT<\\/b><\\/td>\\n<td><b>OUTPUT<\\/b><\\/td>\\n<\\/tr>\\n<tr style=\\\"background:#def; text-align:center;\\\">\\n<td>A<\\/td>\\n<td>B<\\/td>\\n<td>A NAND B<\\/td>\\n<\\/tr>\\n<tr style=\\\"background:#dfd; text-align:center;\\\">\\n<td>0<\\/td>\\n<td>0<\\/td>\\n<td>1<\\/td>\\n<\\/tr>\\n<tr style=\\\"background:#dfd; text-align:center;\\\">\\n<td>0<\\/td>\\n<td>1<\\/td>\\n<td>1<\\/td>\\n<\\/tr>\\n<tr style=\\\"background:#dfd; text-align:center;\\\">\\n<td>1<\\/td>\\n<td>0<\\/td>\\n<td>1<\\/td>\\n<\\/tr>\\n<tr style=\\\"background:#dfd; text-align:center;\\\">\\n<td>1<\\/td>\\n<td>1<\\/td>\\n<td>0<\\/td>\\n<\\/tr>\\n<\\/tbody><\\/table>\\n\\n\\n$x_1 = 0$, $x_2 = 0$\\n$ (−2)\\\\times 0+(−2)\\\\times 0+3=(−2)\\\\times 0+(−2)\\\\times 0+3=3 > 0 \\\\rightarrow 1$\\n$x_1 = 0$, $x_2 = 1$\\n$ (−2)\\\\times 0+(−2)\\\\times 1+3=(−2)\\\\times 0+(−2)\\\\times 1+3=1 > 0 \\\\rightarrow 1$\\n$x_1 = 1$, $x_2 = 0$\\n$ (−2)\\\\times 1+(−2)\\\\times 0+3=(−2)\\\\times 1+(−2)\\\\times 0+3=1 > 0 \\\\rightarrow 1$\\n$x_1 = 1$, $x_2 = 1$\\n$ (−2)\\\\times 1+(−2)\\\\times 1+3=(−2)\\\\times 1+(−2)\\\\times 1+3=-1 < 0 \\\\rightarrow 0$\\n\\n시그모이드를 통과하면 1,1,1,0의 값들로 된다.\\n디지털 회로에서는 복수개의 NAND 게이트를 조합하면 어떤 디지털 로직이라도 구현 가능하다. 예를 들어 다음 회로는 두 입력 신호의 합과 자릿수를 반환하는 반가산기(half adder) 회로이다.\\n<img src=\\\"https:\\/\\/datascienceschool.net\\/upfiles\\/3002b65c9f034818a318ad7f6b09671f.png\\\">\\n이 퍼셉트론 조합을 보면 4개의 퍼셉트론을 연결하여 XOR 로직을 구현하였음을 알 수 있다.\\n다계층 퍼셉트론 (MLP: Multi-Layer Perceptrons)\\n\\n이런 것을 여러 개 그렸을 때 이런 그림이 나온다. 2차 다항식은 차원이 하나 늘어난 것이고 RBF의 경우에는 무한대다.\\n이왕 히든 레이어 만든 거 여러개 더 만들면 되지 않느냐? 바이너리 클레시피케이션 하는 애다. 아웃풋 레이어.\\n히든레이어 15개 썼다는 것은 PCA와 같은 개념. 리니어에 시그모이드를 통과하면 리니어가 안 된다. 이 모델에서 선택적으로 15개 쓴 것이다. 1개 쓰는 케이스는 뭘까? 그것은 압축기다. 784개 들어가서 15개 히든으로 쓰고 784개로 아웃풋 나와서 비슷한게 나오는 웨이트를 발견했다면 압축기가 만들어진 것이다. 오토인코더라고 부른다.\\n보통은 앞단이 엄청 많고 히든은 그거보다 좀 적고 아웃풋은 그거보다 좀 더 적다.\\n\\n신경망은 퍼셉트론을 여러개 연결한 것으로 다계층 퍼셉트론(MLP: Multi-Layer Perceptrons)이라고도 한다. 신경망에 속한 퍼셉트론은 뉴론(neuron) 또는 노드(node)라고 불린다.\\n각 계층(layer)은 다음 계층에 대해 적응형 기저 함수의 역할을 한다. 최초의 계층은 입력 계층(input layer), 마지막 계측은 출력 계층(output layer)이라고 하며 중간은 은닉 계층(hidden layer)라고 한다.\\n<img...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<hr>\\n\\nVaccine effectiveness and &ldquo;herd immunity&rdquo;\\n&ldquo;Herd immunity&rdquo; has somewhat varying meanings, but: \\n\\n&ldquo;A common implication of the term is that the risk of infection among susceptible individuals in a population is reduced by the presence and proximity of immune individuals (this is sometimes referred to as “indirect protection” or a “herd effect”).&rdquo;<sup><a href=\\\"#id1\\\">1<\\/a><\\/sup>\\n\\nHerd immunity depends on\\n\\nthe percent of that population vaccinated (the vaccination rate) and \\nthe effectiveness of the vaccine.\\n\\n$$vaccine\\\\ effectiveness \\\\cdot vaccination\\\\ rate = herd\\\\ immunity$$\\n<hr>\\n\\nEffectiveness: Measles\\nThe vaccination for measles is categorized in this dataset as measles, which the data dictionary does not describe any further except to say that this field is a count of students who have had two doses of a measles-containing vaccine.\\nWe reached out to Stacy Matthews, the Oregon Public Health Division's immunization school law coordinator to request more comprehensive information on what vaccine this would have been, and she said that this was almost always MMR, but may have been a different vaccine in some cases.\\nThe effectiveness rate of two doses of MMR for measles is 97%.\\n\",\"targets\":\"measles_1 = 0.93\\nmeasles_2 = 0.97\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Cell Description\\nThis cell is responsible for building and submitting the Streams applications to the Streams cluster. \\nHealthcare Patient Python Topology Application\\nThis cell contains source code for the Python Topology application. As described in the above architecture, this is a Streaming Python application that ingests the patient data from the ingest-physionet topic, performs filtering and analysis on the data, and then sends the data to the Streams view server.\\n\",\"targets\":\"from healthdemo.patientmonitoring_functions import streaming_rpeak\\nfrom healthdemo.healthcare_functions import PatientFilter, GenTimestamp, aggregate\\nfrom healthdemo.windows import SlidingWindow\\n\\ndef getPatientView(patient_id):\\n    '''\\n    Select data of given patient_id, perform analysis and return view.\\n    \\n    Parameters\\n    ----------\\n    patient_id: int\\n      patient_id (1-based)\\n      \\n    Returns\\n    -------\\n    view: topology.View\\n      view data from Streams server\\n    '''\\n    topo = Topology('HealthcareDemo_Patient%d' % (patient_id))\\n\\n    ## Ingest, preprocess and aggregate patient data\\n    sample_rate = 125\\n    patient_data = topo.subscribe('ingest-physionet', schema.CommonSchema.Json) \\\\\\n                       .map(functions.identity) \\\\\\n                       .filter(PatientFilter('patient-%d' % (patient_id))) \\\\\\n                       .transform(GenTimestamp(sample_rate)) \\\\\\n                       .transform(SlidingWindow(length=sample_rate, trigger=sample_rate-1)) \\\\\\n                       .transform(aggregate)\\n                        \\n    ## Calculate RPeak and RR delta\\n    patient_data = streaming_rpeak(patient_data, sample_rate, data_label='ECG Lead II')\\n\\n    ## Create a view of the data\\n    patient_view = patient_data.view()\\n    \\n    submit('ANALYTICS_SERVICE', topo, config)\\n    return patient_view\\n    \\n# Retrieve view for a patient    \\npatient_view = getPatientView(2)\\n    \\nprint('DONE')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"721 expenses reimbursed to parties.\\n\",\"targets\":\"parties = congressperson_list[congressperson_list['party'].isnull()]\\nparties\\n\\nparty_expenses = data[data['applicant_id'].isin(parties['applicant_id'])]\\nlen(party_expenses)\\n\\nparty_expenses.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Ancient Codes and Partially Developed Tools\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n### Store data to a pickle file\\n# saved_filename = '\\/global\\/homes\\/b\\/bpb\\/Downloads\\/20160818_POS_MO_HEfungusonly_V1.pkl'\\n# with open(output_filename,'w') as f:\\n#     dill.dump(metatlas_dataset,f)\\n\\n### Load a pre-existing metatlas dataset  \\n# metatlas_dataset = ma_data.get_dill_data(saved_filename)\\n\\n### copy files to $SCRATCH\\n### You will likely never have to do this, but just in case, here is the code.\\n# from shutil import copyfile\\n# scratch = os.environ['SCRATCH']\\n# for my_group in groups:\\n#     for my_file in my_group.items:\\n#         new_path = os.path.join(scratch,'temp_metatlas')\\n#         if not os.path.isdir(new_path):\\n#             os.mkdir(new_path)\\n#         new_file = os.path.join(new_path,os.path.basename(my_file.hdf5_file))\\n#         copyfile(my_file.hdf5_file, new_file)\\n#         my_file.hdf5_file = new_file\\n#         print my_file.hdf5_file\\n\\n# %matplotlib inline\\n# dp = reload(dp)\\n# pickles = ['\\/global\\/homes\\/b\\/bpb\\/Downloads\\/KZ_Avena_Exudate_atlases_and_groups_1\\/neg_data.pkl',\\n#           '\\/global\\/homes\\/b\\/bpb\\/Downloads\\/KZ_Avena_Exudate_atlases_and_groups_1\\/pos_data.pkl',\\n# '\\/global\\/homes\\/b\\/bpb\\/Downloads\\/KZ_Avena_Uptake_atlases_and_group_2\\/pos_data.pkl',\\n# '\\/global\\/homes\\/b\\/bpb\\/Downloads\\/KZ_Avena_Uptake_atlases_and_group_2\\/neg_data.pkl']\\n# for p in pickles:\\n#     plot_location_label = p.split('.')[0]+'\\/'\\n#     print plot_location_label\\n#     if not os.path.exists(plot_location_label):\\n#         os.makedirs(plot_location_label)\\n#     metatlas_dataset = ma_data.get_dill_data(p)\\n#     dp.make_identification_figure(input_dataset = metatlas_dataset, input_fname = p, include_lcmsruns = [],exclude_lcmsruns = ['RootCass','QC','Blank','blank'], output_loc=plot_location_label+'\\/identification')\\n\\n######### DO NOT USE #######\\n# output_filename = '\\/global\\/homes\\/b\\/bpb\\/Downloads\\/20160531_KBL_C18_Vio_cells_384_Q_1_to_4.pkl'\\n# data = dp.get_data_for_groups_and_atlas(groups,myAtlas,output_filename)\\n############################\\n\\n######### DO NOT USE #######\\n### THIS STILL NEEDS SOME REPAIRS ###\\n#...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Euler\\/euler_1-10.ipynb\\\".\\nThe first task is:\\n10: Summation of primes\\nThe sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.\\nFind the sum of all the primes below two million.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnp.sum(primesfrom2to(2000000))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Animation\\nHere's a draw function we can use to animate the results.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom matplotlib.pyplot import plot\\n\\nxlim = results.x.min(), results.x.max()\\nylim = results.y.min(), results.y.max()\\n\\ndef draw_func(t, state):\\n    plot(state.x, state.y, 'bo')\\n    decorate(xlabel='x position (m)',\\n             ylabel='y position (m)',\\n             xlim=xlim,\\n             ylim=ylim)\\n\\n# animate(results, draw_func)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Beta function contributions to the partial wave matrices (w\\/ factor of -3\\/2 included)\\n\",\"targets\":\"def bMy1s1(l1, l3):\\n    return -(3\\/2)*My1s1(*betafunctions(l1, l3))\\ndef bMy1s0(l1, l3):\\n    return -(3\\/2)*My1s0(*betafunctions(l1, l3))\\ndef bMy0s1(l1, l3):\\n    return -(3\\/2)*My0s1(*betafunctions(l1, l3))\\ndef bMy0s0(l1, l3):\\n    return -(3\\/2)*My0s0(*betafunctions(l1, l3))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Calculate the partial derivative of cost with respect to m while treating c as a constant.\\ndef gradient_descent_m(x, y, m, c):\\n  return -2.0 * np.sum(x * (y - m * x - c))\\n\\n# Calculate the partial derivative of cost with respect to c while treating m as a constant.\\ndef gradient_descent_c(x, y, m , c):\\n  return -2.0 * np.sum(y - m * x - c)\\n\\neta = 0.0001\\ng_m, g_c = 1.0, 1.0\\nchange = True\\n\\n# Iterate the partial derivatives until the outcomes do not change\\nwhile change:\\n  g_m_new = g_m - eta * gradient_descent_m(setosa_data[2], setosa_data[3], g_m, g_c)\\n  g_c_new = g_c - eta * gradient_descent_c(setosa_data[2], setosa_data[3], g_m, g_c)\\n  if g_m == g_m_new and g_c == g_c_new:\\n    change = False\\n  else:\\n    g_m, g_c = g_m_new, g_c_new\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUse gradient descent\\nGradient Descent is an approximation technique. To utilize this approximation technique, we guess the value that we wish to approximate and iteratively improve that guess.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Assim, podemos calcular a probabilidade de um novo indivíduo ser do sexo masculino.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nP(sexo_m, PDSexo)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Gurobi_v_Cplex__Pmedian.ipynb\\\".\\nThe first task is:\\n<font size='5' face='Times New Roman'><b>2.2b <u>Instantiate Selected Cplex <i>p<\\/i>-median shapefile<\\/u><\\/b><\\/font>\\nCan you write Python code for it?\\n\",\"targets\":\"\\nSHP_Median_CPLEX = shp.Writer(shp.POINT)\\n# Add Points\\nfor idy,idx,x,y in NEW_Records_PMP_CPLEX:\\n    SHP_Median_CPLEX.point(float(x), float(y))\\n# Add Fields\\nSHP_Median_CPLEX.field('y_ID')\\nSHP_Median_CPLEX.field('x_ID')\\nSHP_Median_CPLEX.field('LAT')\\nSHP_Median_CPLEX.field('LON')\\n# Add Records\\nfor idy,idx,x,y in NEW_Records_PMP_CPLEX:\\n    SHP_Median_CPLEX.record(idy,idx,x,y)\\n# Save Shapefile    \\nSHP_Median_CPLEX.save('shapefiles\\/Selected_Locations_Pmedian_CPLEX')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"And let's see how accurate we are:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnp.sum(y_flip == predicted_y)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<hr\\/>\\n\\nVoting Classifier\\nThis is a very basic method of constructing an aggregated classifier from a finite dictionary.\\nLet $\\\\mathcal{V}$ be the set of classifiers (voters), with each calssifier's class probablilites\\ngiven by $\\\\hat{f}_v:\\\\mathcal{X}\\\\mapsto\\\\mathbb{[0,1]}^K$ and prediction\\n$\\\\hat{g}_v(x) = \\\\mathtt{MAJ}(\\\\hat{f}_v(x))$.\\nThe majority vote over $K$ candidates with weights $(w_k){k=1}^K\\\\in \\\\mathbb{R}$ is defined as\\n$$ \\\\mathtt{MAJ}(w) = \\\\mathop{\\\\text{argmax}}{k=1\\\\,\\\\ldots, K} w_k \\\\,. $$\\nHard voting collects label-prediction of each voter, counts the voting proportions and,\\nthen predict the label with the most votes. Mathematically the following aggregation is\\nused:\\n$$ \\\\hat{g}^{\\\\text{maj}}\\\\mathcal{V}(x)\\n    = \\\\mathtt{MAJ}\\\\Bigl( W^{-1} \\\\sum{v\\\\in \\\\mathcal{V}} w_v e_{\\\\hat{g}v(x)} \\\\Bigr)\\n    \\\\,, $$\\nwhere $e_k$ is the $k$-th unit vector in ${0,1}^{K\\\\times 1}$, and $W = \\\\sum{v\\\\in \\\\mathcal{V}} w_v$.\\nSoft voting uses the class-probabilities functions directly: it computes the weighted\\naverage probability of each class over all voters, and then selects the class with the\\nhighest posterior probability. Namely,\\n$$ \\\\hat{g}^{\\\\text{maj}}\\\\mathcal{V}(x)\\n    = \\\\mathtt{MAJ}\\\\bigl( W^{-1} \\\\sum{v\\\\in \\\\mathcal{V}} w_v \\\\hat{f}_v(x) \\\\bigr)\\n    \\\\,. $$\\nAs in Bagging, if the base classifiers are well calibrated, then hard voting\\nwill ovrestimate probabilities.\\nUsage\\n\",\"targets\":\"from sklearn.ensemble import VotingClassifier\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"11-InfraredMeasurementAndAnalysis.ipynb\\\".\\nThe first task is:\\nThe following graph plots the source radiance versus source temperature, for the instrument spectral response, as defined in the input files.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ncalData.LU.PlotCalTempRadiance()\\n# HTML('<img src=\\\"images\\/lwir100mm0150us10ND20090910-CalTempRadiance.png\\\" width=800 \\/>')\\n# display(Image(filename='lwir100mm0150us10ND20090910-CalTempRadiance.png'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Applied Plotting in Python\\/Week 2\\/.ipynb_checkpoints\\/Week 2 - course-checkpoint.ipynb\\\".\\nThe first task is:\\nBar Charts\\nCan you write Python code for it?\\n\",\"targets\":\"\\nplt.figure()\\nxvals = range(len(linear_data))\\nplt.bar(xvals, linear_data, width = 0.3)\\n\\nnew_xvals = []\\n\\n# plot another set of bars, adjusting the new xvals to make up for the first set of bars plotted\\nfor item in xvals:\\n    new_xvals.append(item+0.3)\\n\\nplt.bar(new_xvals, exponential_data, width = 0.3 ,color='red')\\n\\nfrom random import randint\\nlinear_err = [randint(0,15) for x in range(len(linear_data))] \\n\\n# This will plot a new set of bars with errorbars using the list of random error values\\nplt.bar(xvals, linear_data, width = 0.3, yerr=linear_err)\\n\\n# stacked bar charts are also possible\\nplt.figure()\\nxvals = range(len(linear_data))\\nplt.bar(xvals, linear_data, width = 0.3, color='b')\\nplt.bar(xvals, exponential_data, width = 0.3, bottom=linear_data, color='r')\\n\\n# or use barh for horizontal bar charts\\nplt.figure()\\nxvals = range(len(linear_data))\\nplt.barh(xvals, linear_data, height = 0.3, color='b')\\nplt.barh(xvals, exponential_data, height = 0.3, left=linear_data, color='r')\\n\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\n\\nplt.figure()\\n\\nlanguages =['Python', 'SQL', 'Java', 'C++', 'JavaScript']\\npos = np.arange(len(languages))\\npopularity = [56, 39, 34, 34, 29]\\n\\nplt.bar(pos, popularity, align='center')\\nplt.xticks(pos, languages)\\nplt.ylabel('% Popularity')\\nplt.title('Top 5 Languages for Math & Data \\\\nby % popularity on Stack Overflow', alpha=0.8)\\n\\n#TODO: remove all the ticks (both axes), and tick labels on the Y axis\\n\\nax = plt.gca()\\nax.set_yticklabels([])\\nax.tick_params(top=\\\"off\\\", bottom=\\\"off\\\", left=\\\"off\\\", right=\\\"off\\\", labelleft=\\\"off\\\", labelbottom=\\\"on\\\")\\nplt.show()\\n\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\n\\nplt.figure()\\n\\nlanguages =['Python', 'SQL', 'Java', 'C++', 'JavaScript']\\npos = np.arange(len(languages))\\npopularity = [56, 39, 34, 34, 29]\\n\\nplt.bar(pos, popularity, align='center')\\nplt.xticks(pos, languages)\\nplt.ylabel('% Popularity')\\nplt.title('Top 5 Languages for Math & Data \\\\nby % popularity on Stack Overflow', alpha=0.8)\\n\\n# remove all the ticks (both axes), and tick labels on the Y...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Lightcurve\\/Lightcurve tutorial.ipynb\\\".\\nThe first task is:\\nLet's add some badly formatted GTIs:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ngti = [(10, 100), (20, 30, 40), ((1, 2), (3, 4, (5, 6)))] # not a well-behaved GTI\\nlc = Lightcurve(time, counts, dt=0.1, skip_checks=True, gti=gti)\\n\\nlc.check_lightcurve()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"2015_2016\\/lab12\\/Morse Complex.ipynb\\\".\\nThe first task is:\\nLet us try the code on the complex K (full triangle).\\nCan you write Python code for it?\\n\",\"targets\":\"\\nV, C = generate_field(K)\\nprint(V, C)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#Get Parliament session dates from Parliament API\\npsd=pd.read_csv('http:\\/\\/lda.data.parliament.uk\\/sessions.csv?_view=Sessions&_pageSize=50')\\npsd\\n\\ndef getParliamentDate(session):\\n    start=psd[psd['display name']==session]['start date'].iloc[0]\\n    end=psd[psd['display name']==session]['end date'].iloc[0]\\n    return start, end\\n\\ngetParliamentDate('2015-2016')\\n\\n#Check the columns in the Hansard dataset, along with example values\\ndf=drill.query(''' SELECT * from dfs.tmp.`\\/senti_post_v2.parquet` LIMIT 1''').to_dataframe()\\nprint(df.columns.tolist())\\ndf.iloc[0]\\n\\n# Example of count of speeches by person in the dataset as a whole\\nq='''\\nSELECT proper_name, COUNT(*) AS number \\nFROM dfs.tmp.`\\/senti_post_v2.parquet`\\nGROUP BY proper_name\\n'''\\n\\ndf=drill.query(q).to_dataframe()\\ndf.head()\\n\\n# Example of count of speeches by gender in the dataset as a whole\\nq=\\\"SELECT gender, count(*) AS `Number of Speeches` FROM dfs.tmp.`\\/senti_post_v2.parquet` GROUP BY gender\\\"\\ndrill.query(q).to_dataframe()\\n\\n#Query within session\\nsession='2015-2016'\\n\\nstart,end=getParliamentDate(session)\\nq='''\\nSELECT '{session}' AS session, gender, count(*) AS `Number of Speeches`\\nFROM dfs.tmp.`\\/senti_post_v2.parquet`\\nWHERE speech_date>='{start}' AND speech_date<='{end}'\\nGROUP BY gender\\n'''.format(session=session, start=start, end=end)\\n\\ndrill.query(q).to_dataframe()\\n\\n#Count number of speeches per person\\nstart,end=getParliamentDate(session)\\nq='''\\nSELECT '{session}' AS session, gender, mnis_id, count(*) AS `Number of Speeches`\\nFROM dfs.tmp.`\\/senti_post_v2.parquet`\\nWHERE speech_date>='{start}' AND speech_date<='{end}'\\nGROUP BY mnis_id, gender\\n'''.format(session=session, start=start, end=end)\\n\\ndrill.query(q).to_dataframe().head()\\n\\n# Example of finding the average number of speeches per person by gender in a particular session\\nq='''\\nSELECT AVG(gcount) AS average, gender, session\\nFROM (SELECT '{session}' AS session, gender, mnis_id, count(*) AS gcount\\n        FROM dfs.tmp.`\\/senti_post_v2.parquet`\\n        WHERE speech_date>='{start}' AND speech_date<='{end}'\\n       ...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe Hansard data gives the date of each speech but not the session. To search for speeches within a particular session, we need the session dates. We can get these from the Parliament data API.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create the bag of words\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.feature_extraction.text import CountVectorizer\\nvectorizer = CountVectorizer(analyzer = \\\"word\\\",   \\\\\\n                             tokenizer = None,    \\\\\\n                             preprocessor = None, \\\\\\n                             stop_words = None,   \\\\\\n                             max_features = 5000) \\n\\ntrain_data_features = vectorizer.fit_transform(data['lower'])\\n\\n# Numpy arrays are easy to work with, so convert the result to an \\n# array\\ntrain_data_features = train_data_features.toarray()\\n\\n# let's see what we have there\\nvectorizer.get_feature_names()[-5:]\\n\\nlen(data)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Chapter2\\/chptr2.3.ipynb\\\".\\nThe first task is:\\nCI for continuous data, Pg 18\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# import the t-distribution from scipy.stats\\nfrom scipy.stats import t\\n\\ny = np.array([35,34,38,35,37])\\ny\\n\\nn = len(y)\\nn\\n\\nestimate = np.mean(y)\\nestimate\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create Experiment with never resume.\\nkclient.create_experiment(experiment_never_resume,namespace=namespace)\\n# Create Experiment with from volume resume.\\nkclient.create_experiment(experiment_from_volume_resume,namespace=namespace)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreate other Experiments.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Coefficients to find\\n\",\"targets\":\"w_true = [3,3,3]\\nw_true = w_true \\/ np.sum(w_true)\\n\\nmu_true = [3,10,20]\\n\\nsigma_true = [2,4,1]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2. A Simple Example\\nBefore going too much into preprocessing, feature extraction and other more complicated tasks, we will do a relatively simple but complete example. In this example, we will use bag-of-words as features, and Naive Bayes as classifier to establish our baseline.\\nThere are some built-in vectorizers, CountVectorizer and TfidfVectorizer that we can use to vectorizer our raw data and perform preprocessing and feature exctration on it. First, we will experiment with CountVectorizer which basically makes a token\\/ngram a feature and stores its count in the corresponding feature space. The fit_transform() function is the combination of fit() and transform(), and it's a more efficient implementation. fit() indexes the vocabulary\\/features, and transform() transforms the dataset into a matrix.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.feature_extraction.text import CountVectorizer\\n# initialize a CountVectorizer\\ncv = CountVectorizer()\\n# fit the raw data into the vectorizer and tranform it into a series of arrays\\nX_train_counts = cv.fit_transform(X_train)\\nX_train_counts.shape\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Chart_Samples.ipynb\\\".\\nThe first task is:\\nThis graph shows a trend towards a lower average score, as well as a greater abundance of low scores, with time. This is probably at least partially a selection effect -- Rotten Tomatoes probably doesn't archive reviews for all movies, especially ones that came out before the website existed. Thus, reviews of old movies are more often \\\"the classics\\\". Mediocre old movies have been partially forgotten, and are underrepresented in the data. Other questions worth exploring:\\nDoes the down trend mean:\\n* the quality of movies has dropped ?\\n* the top critics became more stringent in giving higher ratings?\\n* more top critics with stringent ratings entered the scene?\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf=pd.read_csv(\\\"01_heights_weights_genders.csv\\\")\\ndf.head()\\n\\nfrom sklearn.linear_model import LogisticRegression\\nclf_l, Xtrain_l, ytrain_l, Xtest_l, ytest_l  = do_classify(LogisticRegression(), {\\\"C\\\": [0.01, 0.1, 1, 10, 100]}, df, ['Weight', 'Height'], 'Gender','Male')\\n\\nplt.figure(figsize =(12,8))\\nplt.xlabel(\\\"Weight\\\")\\nplt.ylabel(\\\"Height\\\")\\nax=plt.gca()\\npoints_plot(ax, Xtrain_l, Xtest_l, ytrain_l, ytest_l, clf_l, alpha=0.2);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Algorithm to simulate GMRF with block-circulant\\n\",\"targets\":\"## Simulate random noise (Normal distributed)\\nzr = scipy.stats.norm.rvs(size=(C.size,2),loc=0,scale=1)\\nzr.dtype=np.complex_\\n#plt.hist(zr.real)\\n\\n\\nfrom scipy.fftpack import ifft2, fft2\\n\\nLm = scipy.sqrt(C.shape[0]*C.shape[0]) * fft2(C)\\n\\nLm.shape\\n\\nzr.shape\\n\\nLm.size\\n\\n%time v = fft2(scipy.sqrt(Lm) * zr.reshape(Lm.shape))\\n\\nx = v.real\\n\\nx.shape\\n\\nplt.imshow(x,interpolation='None')\\n\\ncc = scipy.linalg.inv(C)\\n\\nplt.plot(cc[:,0])\\n\\nn = x.shape[0]\\nmm = scipy.stats.multivariate_normal(np.zeros(n),cc)\\n\\nmmm = mm.rvs()\\n\\nplt.imshow(mmm.reshape(100,100))\\n\\nscipy.stats.multivariate_normal?\\n\\nnn = mm.rvs()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create and execute an online query\\nNow that your index is deployed, you can make queries.\\nFirst, you construct a vector query using synthetic data, to use as the example to return matches for.\\nNext, you make the matching request using the method match(), with the following parameters:\\n\\ndeployed_index_id:  The identifier of the deployed index.\\nqueries: A list of queries (instances).\\nnum_neighbors: The number of closest matches to return.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# The number of nearest neighbors to be retrieved from database for each query.\\nNUM_NEIGHBOURS = 10\\n\\n# Test query\\nqueries = [\\n    [\\n        -0.11333,\\n        0.48402,\\n        0.090771,\\n        -0.22439,\\n        0.034206,\\n        -0.55831,\\n        0.041849,\\n        -0.53573,\\n        0.18809,\\n        -0.58722,\\n        0.015313,\\n        -0.014555,\\n        0.80842,\\n        -0.038519,\\n        0.75348,\\n        0.70502,\\n        -0.17863,\\n        0.3222,\\n        0.67575,\\n        0.67198,\\n        0.26044,\\n        0.4187,\\n        -0.34122,\\n        0.2286,\\n        -0.53529,\\n        1.2582,\\n        -0.091543,\\n        0.19716,\\n        -0.037454,\\n        -0.3336,\\n        0.31399,\\n        0.36488,\\n        0.71263,\\n        0.1307,\\n        -0.24654,\\n        -0.52445,\\n        -0.036091,\\n        0.55068,\\n        0.10017,\\n        0.48095,\\n        0.71104,\\n        -0.053462,\\n        0.22325,\\n        0.30917,\\n        -0.39926,\\n        0.036634,\\n        -0.35431,\\n        -0.42795,\\n        0.46444,\\n        0.25586,\\n        0.68257,\\n        -0.20821,\\n        0.38433,\\n        0.055773,\\n        -0.2539,\\n        -0.20804,\\n        0.52522,\\n        -0.11399,\\n        -0.3253,\\n        -0.44104,\\n        0.17528,\\n        0.62255,\\n        0.50237,\\n        -0.7607,\\n        -0.071786,\\n        0.0080131,\\n        -0.13286,\\n        0.50097,\\n        0.18824,\\n        -0.54722,\\n        -0.42664,\\n        0.4292,\\n        0.14877,\\n        -0.0072514,\\n        -0.16484,\\n        -0.059798,\\n        0.9895,\\n        -0.61738,\\n        0.054169,\\n        0.48424,\\n        -0.35084,\\n        -0.27053,\\n        0.37829,\\n        0.11503,\\n        -0.39613,\\n        0.24266,\\n        0.39147,\\n        -0.075256,\\n        0.65093,\\n        -0.20822,\\n        -0.17456,\\n        0.53571,\\n        -0.16537,\\n        0.13582,\\n        -0.56016,\\n        0.016964,\\n        0.1277,\\n        0.94071,\\n        -0.22608,\\n        -0.021106,\\n    ],\\n    [\\n        -0.99544,\\n        -2.3651,\\n        -0.24332,\\n        -1.0321,\\n        0.42052,\\n        -1.1817,\\n        -0.16451,\\n        -1.683,\\n      ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Using the test sample conaining only selected predictors\\nyhat_test = linreg.predict(Xtest) # Predict \\nmse_test = np.mean(np.power(yhat_test - ytest, 2))\\n\\n# Form the matrix from the RAW set\\nXm = Xtrain.as_matrix()\\nym = ytrain.as_matrix()\\n\\nfrom sklearn.model_selection import KFold\\n\\ndef doKFold(Xt, yt, K):\\n    # Using K = 5\\n    kf = KFold(n_splits=K)\\n    mse_cv = 0\\n    for train_indeces, test_indeces in kf.split(Xm):\\n        # Select only the most relevant attributes\\n        # In the previous section we chose attributes with index 2, 9 and 10\\n        # as the most relevant.\\n        Xtrain_k = Xtrain.iloc[train_indeces].as_matrix()\\n        Xtest_k = Xtrain.iloc[test_indeces].as_matrix()\\n        ytrain_k = ytrain.iloc[train_indeces].as_matrix()\\n        ytest_k = ytrain.iloc[test_indeces].as_matrix()\\n\\n        # Perform linear regression for this fold\\n        linreg = lm.LinearRegression(fit_intercept = False)\\n        linreg.fit(Xtrain_k, ytrain_k)\\n\\n        # Get the yhat for our test set\\n        yhat_val = linreg.predict(Xtest_k)\\n\\n        # Calculate the MSE for the error\\n        mse_fold = np.mean(np.power(yhat_val - ytest_k, 2))\\n        mse_cv += mse_fold\\n    mse_cv = mse_cv \\/ K\\n    return mse_cv\\n\\n\\n{\\\"mse5\\\": doKFold(Xtrain, ytrain, 5), \\\"mse10\\\": doKFold(Xtrain, ytrain, 10), \\\"mse_test\\\": mse_test}\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nEsto implica que los atributos seleccionados son similarmente importantes en la predicción del precio.\\ng) Estime el error de predicción del modelo usando validación cruzada con un número de folds igual a K\\n= 5 y K = 10. Recuerde que para que la estimación sea razonable, en cada configuración (fold) deberá\\nreajustar los pesos del modelo. Mida el error real del modelo sobre el conjunto de pruebas, compare y\\nconcluya.\\nAsumiendo que se debe utilizar el modelo con la selección de atributos seleccionada anteriormente, se tiene:\",\"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.atmos.key_properties.resolution.range_horizontal_resolution')  \\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\":\"\\n2.3. Range Horizontal Resolution\\nIs Required: TRUE&nbsp;&nbsp;&nbsp;&nbsp;Type: STRING&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 1.1\\nRange of horizontal resolution with spatial details, eg. 1 deg (Equator) - 0.5 deg\",\"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_memmap\\/03_memmap.ipynb\\\".\\nThe first task is:\\nAbout groups and hierarchical organization...\\nAn HDF5 file is a container for two kinds of objects: datasets, which are array-like collections of data, and groups, which are folder-like containers that hold datasets and other groups. The most fundamental thing to remember when using h5py is:\\nGroups work like folders, and datasets work like NumPy arrays!\\n<img src='data\\/hdf5.jpg' style=\\\"width: 600px;\\\">\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# The File object we created is itself a group, in this case the root group\\nprint( f.name )\\nprint( dset.name )\\n\\n# Lets create a subgroup\\nf.create_group(\\\"subgroup\\\")\\n\\n# Lets create a new dataset inside this subgroup\\ndset2 = f.create_dataset('subgroup\\/dataset2', (10,), dtype='i')\\nprint(dset2.name)\\n\\n# Retrieving datasets\\/arrays from hdf5 file\\nprint( f[\\\"dataset\\\"] )\\nprint( f[\\\"subgroup\\/dataset2\\\"] )\\n\\nf.close()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create Module\\nThe most widely used module class is Module, which wraps a Symbol and one or more Executors.\\nWe construct a module by specify\\n\\nsymbol : the network Symbol\\ncontext : the device (or a list of devices) for execution\\ndata_names : the list of data variable names \\nlabel_names : the list of label variable names\\n\\nOne can refer to data.ipynb for more explanations about the last two arguments. Here we have only one data named data, and one label, with the name softmax_label, which is automatically named for us following the name softmax we specified for the SoftmaxOutput operator.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmod = mx.mod.Module(symbol=net, \\n                    context=mx.cpu(),\\n                    data_names=['data'], \\n                    label_names=['softmax_label'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"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\":\"I am working on the file \\\"ML_SS2017\\/numpy_rachunek_rozniczkowy.ipynb\\\".\\nThe first task is:\\nLaplasjan\\nhttps:\\/\\/en.wikipedia.org\\/wiki\\/Discrete_Laplace_operator\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport sympy\\nfrom sympy.abc import x,y\\nsympy.init_printing(use_latex='mathjax')\\n\\nfrom IPython.display import display\\n\\nf_symb = sympy.sin(x**2+y**2)\\nlap_f = f_symb.diff(x,2) + f_symb.diff(y,2)\\ndisplay(lap_f.simplify())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Dans cas précis, on ne souhaite pas trier sur les nombres mais sur leur parité. En quelque sorte, on ne s'intéresse pas de savoir dans quel ordre deux nombres pairs seront triés. Cela réduit le nombre d'opérations à effectuer. Une idée consiste à parcourir le tableau par les deux bouts et à échanger deux nombres dès que leur parité sont mal classées.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef trie_parite(l):\\n    i = 0\\n    j = len(l)-1\\n    while i < j :\\n        while i < j and l[i]%2 == 0 : i += 1\\n        while i < j and l[j]%2 == 1 : j -= 1\\n        if i < j:\\n            ech = l[i]\\n            l[i] = l[j]\\n            l[j] = ech\\n            i += 1\\n            j -= 1\\n    \\nl = l.copy()\\ntrie_parite(l)\\nl\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# clf_sepal.score?\\n\\nclf_sepal.score(X_train_sepal_only, y_train)\\n\\nclf_sepal.score(X_test_sepal_only, y_test)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nEvaluation: What perecentage in each set is corretly predicted?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Custom Agent\\n<center>\\n<img src=\\\"https:\\/\\/storage.googleapis.com\\/dm-educational\\/assets\\/reinforcement_learning\\/random_policy.png\\\" width=\\\"500\\\" \\/>\\n<\\/center>\\nLet's now try and manually code a better behaviour into the agent. The code below defines a way to run a custom set of actions. A value of 0 for the action means the cart is pushed left, and a value of 1 means the cart is pushed right.\\nCurrently, the code is set to a constant zero, which pushes the cart left all the time (you'll see this if you run it and play the video!).\\nYou can modify the function to specify what action should be taken depending on the observation.\\nOne thing you could try is to use an if statement, which in Python, looks like the following.\\nif [some_condition]:\\n  action = [some_value]\\nelse:\\n  action = [some_other_value]\\nLooking at the code below, you have access to the cart_position, cart_velocity, pole_angle, and pole_velocity_at_tip.\\nCan you think of what conditions you might use to set the actions based on these?\\nAsk for help if you're not sure!\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef custom_action_for_cartpole(state):\\n  # for cartpole only:\\n  cart_position = state[0]\\n  cart_velocity = state[1]\\n  pole_angle = state[2]\\n  pole_velocity_at_tip = state[3]\\n\\n  # Instead of making the action 0 (in cartpole: go left), try to come up with\\n  # a better behavior.\\n  action = 0\\n\\n  return action\\n\\n\\noutput = environment.reset()\\n\\nframes, actions = step_agent_in_environment(\\n    env=environment, agent=custom_action_for_cartpole, num_episodes=5)\\n\\nshow_video(frames)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# SelectKBest for selecting top-scoring features\\n\\nfrom sklearn import datasets\\nfrom sklearn.feature_selection import SelectKBest, chi2\\n\\niris = datasets.load_iris()\\nX, y = iris.data, iris.target\\n\\nprint(X.shape)\\n\\n# Do feature selection\\n#  input is scoring function (here chi2) to get univariate p-values\\n#  and number of top-scoring features (k) - here we get the top 2\\nX_t = SelectKBest(chi2, k = 2).fit_transform(X, y)\\n\\nprint(X_t.shape)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSelecting k top scoring features (also dimensionality reduction)\\n\\nConsidered unsupervised learning\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Examples\\/immune\\/Analyse_pMHC.ipynb\\\".\\nThe first task is:\\nSelect Seed\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnotebook.select_seed.display()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"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:\\nIntegrating PySAL.Network with Gurobi, CPLEX, & COIN-OR for optimization of the p-Center facility location problem\\n\\nJames Gaboardi &nbsp;| &nbsp;Florida State University&nbsp;| &nbsp;Department of Geography\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Local path on user's machine\\npath = '\\/Users\\/jgaboardi\\/FacilityLocation\\/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 \\\"07_SH_waves_in_moons_and_planets\\/4_2D_SHaxi_FD_modelling_ganymede.ipynb\\\".\\nThe first task is:\\nAs usual, we first define the modelling parameters for an axisymmetric Ganymede model. Unfortunately, Ganymede seem to have to solid core, which would require a special treatment of the centre to avoid the singularity at $r = 0\\\\; m$. For simplicity, we assume that Ganymedes inner core with a radius of roughly 700 km is liquid, so we can handle the CMB as free-surface boundary.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Definition of modelling parameters\\n# ----------------------------------\\nrcore = 693.0 * 1000.0      # Ganymede fluid core radius [m]\\nrplanet = 2634.1 * 1000.0   # Ganymede radius [m]\\n\\nnr = 400      # number of spatial gridpoints in r-direction\\ndr = (rplanet - rcore) \\/ nr # spatial gridpoint distance in r-direction\\n\\n# calculate dtheta based on dr\\ndtheta = dr \\/ rcore\\nntheta = (int) (np.pi \\/ dtheta)  # number of spatial gridpoints in theta-direction\\nntheta += 2\\n\\n# Define Ganymede model filename\\nname_model = \\\"ganymede_model\\/ganymede_model.dat\\\"\\n\\n# Acquisition geometry\\ntmax = 2000.0           # maximum recording time of the seismogram (s)\\n\\nisnap = 5  # snapshot interval (timesteps)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Cluster 0 - Second Fewest Lead Changes (rank 3), Second Fewest Events(rank 3), Largest average goal differential (rank 4)\\nCluster 1 - Most Lead Changes (rank 1), Second Most Events (rank 2), Second largest avg goal diff (rank 3)\\nCluster 2 - Second most lead changes (rank 2), most events (rank 1), third largest avg goal diff (rank 2)\\nCluster 3 - fewest lead chanegs (rank 4), fewest events (rank 4), smallest avg goal diff (rank 1)\\n\\nSave match df with clusters and engineered features\\npython\\nmatch_df.to_csv('match_cluster.csv', encoding='utf-8')\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmatch_df = pd.read_csv('match_cluster.csv')\\n\\nmatch_df = match_df.drop(['Unnamed: 0','link_odsp','adv_stats'], axis = 1)\\n\\nengland = match_df[match_df.country == 'england']\\nspain = match_df[match_df.country == 'spain']\\ngermany = match_df[match_df.country == 'germany']\\nfrance = match_df[match_df.country == 'france']\\nitaly = match_df[match_df.country == 'italy']\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"PyIndex.ipynb\\\".\\nThe first task is:\\nCompare results to Whoosh\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef make_clean_index(ix_dirname, paths, procs=1):\\n    ix = whoosh.index.create_in(ix_dirname, schema=simple_schema())\\n    writer = ix.writer(procs=procs)\\n\\n    for filepath in paths:\\n        add_doc(writer, filepath)\\n\\n    writer.commit()\\n    \\n    return ix\\n\\ndef add_doc(writer, filepath):\\n    with open(filepath, 'rb') as f:\\n        text = f.read().decode('latin')\\n    writer.add_document(doc=text, filepath=filepath)\\n\\nt = time.time()\\nix = make_clean_index('wind', sorted(glob.glob('Lincoln\\/*.txt')))\\nprint(\\\"TIME:\\\", time.time() - t)\\n\\nwith ix.searcher() as searcher:\\n    results = searcher.search(q)\\n    print(results)\\n    for hit in results:\\n        print('{:f}'.format(hit.score), ' | ', hit['filepath'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"A simple function to plot the initial condition:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef plotIC():\\n    fig = plt.figure()\\n    axes = fig.add_axes([0.1, 0.1, 0.8, 0.8])\\n    axes.plot(xPoints, initialCondition, 'ro')\\n    axes.set_xlabel('Distance $x$')\\n    axes.set_ylabel('Concentration of Stuff $c(x,t)$')\\n    axes.set_title('Initial Conditions');\\n\\nplotIC()\",\"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.3.1_simple_data_set_v2.ipynb\\\".\\nThe first task is:\\nNow, let us create our <code>toy_set<\\/code> object, and find out the value on index 1 and the length of the inital dataset\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Create Dataset Object. Find out the value on index 1. Find out the length of Dataset Object.\\n\\nour_dataset = toy_set()\\nprint(\\\"Our toy_set object: \\\", our_dataset)\\nprint(\\\"Value on index 0 of our toy_set object: \\\", our_dataset[0])\\nprint(\\\"Our toy_set length: \\\", len(our_dataset))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<a id='counting'><\\/a>\\n3. What can we do with a DTM?\\nWe can do a number of calculations using a DTM. For a toy example, we can quickly identify the most frequent words (compare this to how many steps it took using NLTK).\\n\",\"targets\":\"print(dtm_df.sum().sort_values(ascending=False))\\n\\n##Ex: print the average number of times each word is used in a review\\n#Print this out sorted from highest to lowest.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Build the network\\nFor the neural network, you'll build each layer into a function.  Most of the code you've seen has been outside of functions. To test your code more thoroughly, we require that you put each layer in a function.  This allows us to give you better feedback and test for simple mistakes using our unittests before you submit your project.\\n\\nNote: If you're finding it hard to dedicate enough time for this course each week, we've provided a small shortcut to this part of the project. In the next couple of problems, you'll have the option to use classes from the TensorFlow Layers or TensorFlow Layers (contrib) packages to build each layer, except the layers you build in the \\\"Convolutional and Max Pooling Layer\\\" section.  TF Layers is similar to Keras's and TFLearn's abstraction to layers, so it's easy to pickup.\\nHowever, if you would like to get the most out of this course, try to solve all the problems without using anything from the TF Layers packages. You can still use classes from other packages that happen to have the same name as ones you find in TF Layers! For example, instead of using the TF Layers version of the conv2d class, tf.layers.conv2d, you would want to use the TF Neural Network version of conv2d, tf.nn.conv2d. \\n\\nLet's begin!\\nInput\\nThe neural network needs to read the image data, one-hot encoded labels, and dropout keep probability. Implement the following functions\\n* Implement neural_net_image_input\\n * Return a TF Placeholder\\n * Set the shape using image_shape with batch size set to None.\\n * Name the TensorFlow placeholder \\\"x\\\" using the TensorFlow name parameter in the TF Placeholder.\\n* Implement neural_net_label_input\\n * Return a TF Placeholder\\n * Set the shape using n_classes with batch size set to None.\\n * Name the TensorFlow placeholder \\\"y\\\" using the TensorFlow name parameter in the TF Placeholder.\\n* Implement neural_net_keep_prob_input\\n * Return a TF Placeholder for dropout keep probability.\\n * Name the TensorFlow placeholder \\\"keep_prob\\\" using the TensorFlow name parameter in...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport tensorflow as tf\\n\\ndef neural_net_image_input(image_shape):\\n    \\\"\\\"\\\"\\n    Return a Tensor for a batch of image input\\n    : image_shape: Shape of the images\\n    : return: Tensor for image input.\\n    \\\"\\\"\\\"\\n    # TODO: Implement Function\\n    x = tf.placeholder(tf.float32, shape=[None] + list(image_shape), name='x')\\n    return x\\n\\n\\ndef neural_net_label_input(n_classes):\\n    \\\"\\\"\\\"\\n    Return a Tensor for a batch of label input\\n    : n_classes: Number of classes\\n    : return: Tensor for label input.\\n    \\\"\\\"\\\"\\n    # TODO: Implement Function\\n    y = tf.placeholder(tf.float32, shape=(None, n_classes), name='y')\\n    return y\\n\\n\\ndef neural_net_keep_prob_input():\\n    \\\"\\\"\\\"\\n    Return a Tensor for keep probability\\n    : return: Tensor for keep probability.\\n    \\\"\\\"\\\"\\n    # TODO: Implement Function\\n    keep_prob = tf.placeholder(tf.float32, name='keep_prob')\\n    return keep_prob\\n\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntf.reset_default_graph()\\ntests.test_nn_image_inputs(neural_net_image_input)\\ntests.test_nn_label_inputs(neural_net_label_input)\\ntests.test_nn_keep_prob_inputs(neural_net_keep_prob_input)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"BPE (Byte pair encoding) model\\nSentencepiece supports BPE (byte-pair-encoding) for subword segmentation with --model_type=bpe flag.   We do not find empirical differences in translation quality between BPE and unigram model, but unigram model can perform sampling and n-best segmentation. See subword regularization paper [kudo18] for more detail.\\n\",\"targets\":\"spm.SentencePieceTrainer.train('--input=botchan.txt --model_prefix=m_bpe --vocab_size=2000 --model_type=bpe')\\nsp_bpe = spm.SentencePieceProcessor()\\nsp_bpe.load('m_bpe.model')\\n\\nprint('*** BPE ***')\\nprint(sp_bpe.encode_as_pieces('thisisatesthelloworld'))\\nprint(sp_bpe.nbest_encode_as_pieces('hello world', 5))  # returns an empty list.\\n\\nspm.SentencePieceTrainer.train('--input=botchan.txt --model_prefix=m_unigram --vocab_size=2000 --model_type=unigram')\\nsp_unigram = spm.SentencePieceProcessor()\\nsp_unigram.load('m_unigram.model')\\n\\nprint('*** Unigram ***')\\nprint(sp_unigram.encode_as_pieces('thisisatesthelloworld'))\\nprint(sp_unigram.nbest_encode_as_pieces('thisisatesthelloworld', 5))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%time\\ny_pred = [tagger.tag(xseq) for xseq in X_test]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPredict entity labels for all sentences in our testing set ('testb' Spanish 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 \\\"2016\\/assignment 3.ipynb\\\".\\nThe first task is:\\nUse this cell to explain \\/ expand your answer.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n## 10\\n\\n# Your code goes here\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%matplotlib inline\\n#don't forget the line above!\\nimport glob\\nimport numpy as np\\n\\nfrom matplotlib import pyplot as plt\\n\\n#do something here to take the first 3 files from the list.\\ndata = np.loadtxt(fname='inflammation-01.csv', delimiter=',')\\nplt.figure(figsize=(10.0, 3.0))\\n\\nplt.subplot(1, 3, 1)\\nplt.ylabel('average')\\nplt.plot(data.mean(axis=0))\\n\\nplt.subplot(1, 3, 2)\\nplt.ylabel('max')\\nplt.plot(data.max(axis=0))\\n\\nplt.subplot(1, 3, 3)\\nplt.ylabel('min')\\nplt.plot(data.min(axis=0))\\n\\nplt.tight_layout()\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nConvert the following code (copied from above) to process the first 3 inflammation files and draw 3 graphs (ie. mean, max, min) for each file using \\\"for\\\" loop\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"9 Order Topic Construct\\n\\n<font color=red>countvector， lda transform<\\/font>\\n由商品的Topic构造订单的Topic表达\\n商品加入购物车的次序？？？ 先忽视次序\\n每个用户学习：加购物车次序 VS 重购？ VS下张订单的Topic？？\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\norder_topic = pd.merge(order_products_prior[['order_id', 'product_id']],\\n                       topic_product,\\n                       on = ['product_id'],\\n                       how = 'inner')#throw stop words\\n\\norder_topic = order_topic.groupby(['order_id'])[[\\\"topic_%d\\\"%x for x in range(10)]].sum().reset_index()\\n\\nunorm = order_topic[[\\\"topic_%d\\\"%x for x in range(10)]].values\\n\\norder_topic[[\\\"topic_%d\\\"%x for x in range(10)]] = unorm \\/ unorm.sum(axis = 1)[:,np.newaxis]\\n\\nlen(order_products_prior.product_id.unique())\\n\\nlen(topic_product.product_id.unique())\",\"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_TFRecords_Dataset_API.ipynb\\\".\\nThe first task is:\\nLoad Data\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport knifey\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"CarND-Traffic-Sign-Classifier-Project\\/traffic-sign-classification-with-keras_transfer_cifar10.ipynb\\\".\\nThe first task is:\\nOverview\\nHere are the steps you'll take to build the network:\\n\\nLoad the training data.\\nPreprocess the data.\\nBuild a feedforward neural network to classify traffic signs.\\nBuild a convolutional neural network to classify traffic signs.\\nEvaluate the final neural network on testing data.\\n\\nKeep an eye on the network’s accuracy over time. Once the accuracy reaches the 98% range, you can be confident that you’ve built and trained an effective model.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport pickle\\nimport numpy as np\\nimport math\\n\\n# Fix error with TF and Keras\\nimport tensorflow as tf\\ntf.python.control_flow_ops = tf\\n\\nprint('Modules loaded.')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<div class=\\\"alert alert-success\\\">\\n\\n<b>EXERCISE<\\/b>:\\n\\n <ul>\\n  <li>How many roles in the movie \\\"Inception\\\" are NOT ranked by an \\\"n\\\" value?<\\/li>\\n<\\/ul>\\n<\\/div>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ninception = cast[cast['title'] == 'Inception']\\n\\nlen(inception[inception['n'].isna()])\\n\\ninception['n'].isna().sum()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2. Распределение роста для мужчин и женщин\\nКак мы увидели, в процессе исследования уникальных значений, пол кодируется значениями 1 и 2, расшифровка изначально не была нам дана в описании данных, но мы догадались, кто есть кто, посчитав средние значения роста (или веса) при разных значениях признака gender. Теперь сделаем то же самое, но графически. \\nПостройте violinplot для роста и пола. Используйте:\\n- hue – для разбивки по полу\\n- scale – для оценки количества каждого из полов \\nДля корректной отрисовки, преобразуйте DataFrame в \\\"Long Format\\\"-представление с помощью функции melt в pandas.\\n<br>\\nеще один пример\\nПостройте на одном графике два отдельных kdeplot роста, отдельно для мужчин и женщин. На нем разница будет более наглядной, но нельзя будет оценить количество мужчин\\/женщин.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntrain.head()\\n\\nfiltered_df = train[(train['ap_lo'] <= train['ap_hi']) & \\n                 (train['height'] >= train['height'].quantile(0.025)) &\\n                 (train['height'] <= train['height'].quantile(0.975)) &\\n                 (train['weight'] >= train['weight'].quantile(0.025)) & \\n                 (train['weight'] <= train['weight'].quantile(0.975))]\\n\\ndf = pd.melt(filtered_df, value_vars=['weight'], id_vars='gender')\\nsns.violinplot(x='variable', y='value', hue='gender', data=df)\\n\\nfemale = filtered_df[filtered_df['gender'] == 1]\\nmale = filtered_df[filtered_df['gender'] == 2]\\n\\nax = sns.kdeplot(female.height, female.height,\\n                 cmap=\\\"Reds\\\", shade=True, shade_lowest=False)\\nax = sns.kdeplot(male.height, male.height,\\n                cmap=\\\"Blues\\\", shade=True, shade_lowest=False)\",\"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_PrettyTensor.ipynb\\\".\\nThe first task is:\\nUsing this helper-function we can retrieve the variables. These are TensorFlow objects. In order to get the contents of the variables, you must do something like: contents = session.run(weights_conv1) as demonstrated further below.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nweights_conv1, biases_conv1 = get_weights_variable(layer_name='layer_conv1')\\n#weights_conv2 = get_weights_variable(layer_name='layer_conv2')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"22.2. Growth Respiration\\nIs Required: FALSE&nbsp;&nbsp;&nbsp;&nbsp;Type: STRING&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 0.1\\nDescribe the general method used for growth respiration\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# PROPERTY ID - DO NOT EDIT !  \\nDOC.set_id('cmip6.land.carbon_cycle.vegetation.autotrophic_respiration.growth_respiration')  \\n\\n# PROPERTY VALUE: \\n# Set as follows: DOC.set_value(\\\"value\\\")  \\n# TODO - please enter value(s)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"\\\"\\\"\\nSimple demo with multiple subplots.\\n\\\"\\\"\\\"\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\n\\n\\nx1 = np.linspace(0.0, 5.0)\\nx2 = np.linspace(0.0, 2.0)\\n\\ny1 = np.cos(2 * np.pi * x1) * np.exp(-x1)\\ny2 = np.cos(2 * np.pi * x2)\\n\\nplt.subplot(2, 1, 1)\\nplt.plot(x1, y1, 'yo-')\\nplt.title('A tale of 2 subplots')\\nplt.ylabel('Damped oscillation')\\n\\nplt.subplot(2, 1, 2)\\nplt.plot(x2, y2, 'r.-')\\nplt.xlabel('time (s)')\\nplt.ylabel('Undamped')\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPrettier plot\\nMatplotlib has many options for making pretty plots. Here is an example\\nof a simulated damped oscillator. In this example we're using numpy to generate and keep track of the numerical data.\\nDemo source:\\nhttp:\\/\\/matplotlib.org\\/users\\/screenshots.html\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"GPy-phil\\/ease-of-use.ipynb\\\".\\nThe first task is:\\nIn order to add coregionalization to a model we merely have to create the right kernel, which understands the coregionalization structure in the data:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nkern_coreg = GPy.kern.Coregionalize(1, # Dimensionality of coregionalize input\\n                                    len(sex_uniques), # How many different tasks do we have?\\n                                    rank=3, # How deep is the coregionaliztion,\\n                                    # the higher the rank, the more flexible the\\n                                    # coregionalization, rank >= 1\\n                                    active_dims=[X_train.columns.get_loc('sex')] ,\\n                                    # Which dimension of the input carries the task information?\\n                                    name = 'sex',\\n                                   ) * kern_numeric.copy()\\n\\nfull_model = GPy.models.SparseGPRegression(X_train.values, Y_train.values, kernel=kern_coreg, num_inducing=40)\\n\\nfull_model.optimize(messages=1, max_iters=3e3)\\n\\nW, k = full_model.kern.sex.parameters\\ncoregionalization_matrix = GPy.util.linalg.tdot(W)\\nGPy.util.diag.add(coregionalization_matrix, k)\\n\\nfig, ax = plt.subplots()\\nc = ax.matshow(coregionalization_matrix, cmap=plt.cm.hot)\\nax.set_xticks([0, 1, 2])\\nax.set_xticklabels(sex_uniques[[0, 1, 2]], fontdict=dict(size=23))\\nax.set_yticks([0, 1, 2])\\nax.set_yticklabels(sex_uniques[[0, 1, 2]], fontdict=dict(thickness='bold'))\\nax.xaxis.tick_top()\\nplt.colorbar(c, ax=ax)\\nfig.tight_layout()\\n\\nfull_model.kern.kernel.plot_ARD()\\n_ = plt.legend()\\n\\n# Evaluate the log likelihood for the whole numerical model with coregionalization:\\nresult_df['coreg'] = (\\n    log_likelihood(full_model, X_test.values, Y_test.values),\\n    RMSE(full_model, X_test.values, Y_test.values)\\n)\\n\\nresult_df\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Any time you need more info on a numpy function, we encourage you to look at the official documentation. \\nYou can also create a new cell in the notebook and write np.exp? (for example) to get quick access to the documentation.\\nExercise: Implement the sigmoid function using numpy. \\nInstructions: x could now be either a real number, a vector, or a matrix. The data structures we use in numpy to represent these shapes (vectors, matrices...) are called numpy arrays. You don't need to know more for now.\\n$$ \\\\text{For } x \\\\in \\\\mathbb{R}^n \\\\text{,     } sigmoid(x) = sigmoid\\\\begin{pmatrix}\\n    x_1  \\\\\\n    x_2  \\\\\\n    ...  \\\\\\n    x_n  \\\\\\n\\\\end{pmatrix} = \\\\begin{pmatrix}\\n    \\\\frac{1}{1+e^{-x_1}}  \\\\\\n    \\\\frac{1}{1+e^{-x_2}}  \\\\\\n    ...  \\\\\\n    \\\\frac{1}{1+e^{-x_n}}  \\\\\\n\\\\end{pmatrix}\\\\tag{1} $$\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# GRADED FUNCTION: sigmoid\\n\\nimport numpy as np # this means you can access numpy functions by writing np.function() instead of numpy.function()\\n\\ndef sigmoid(x):\\n    \\\"\\\"\\\"\\n    Compute the sigmoid of x\\n\\n    Arguments:\\n    x -- A scalar or numpy array of any size\\n\\n    Return:\\n    s -- sigmoid(x)\\n    \\\"\\\"\\\"\\n    \\n    ### START CODE HERE ### (≈ 1 line of code)\\n    s = 1. \\/ (1. + np.exp(-x))\\n    ### END CODE HERE ###\\n    \\n    return s\\n\\nx = np.array([1, 2, 3])\\nsigmoid(x)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Clustering_6_hierarchical_clustering_blank.ipynb\\\".\\nThe first task is:\\nLet's visualize the two child clusters:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndisplay_single_tf_idf_cluster(left_child, map_index_to_word)\\n\\ndisplay_single_tf_idf_cluster(right_child, map_index_to_word)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Building a grid\\nIn the sample below, we'll create a simple square grid and fill the grid with households.  The parameters below will guide our model as follows:\\n\\ngrid_size: the number of cells per row or column; the total number of cells is $grid_size^2$.\\ngroup_proportion: the percentage of households that will be of type 1\\ndensity: the percentage of grid cells that will be populated with a household\\n\\nThe logic for our grid initialization can be described as follows:\\n\\nFor each cell in every row and column\\nDraw a random value on $[0, 1)$ and compare to $density$ to determine if we will fill this cell\\nIf the cell will be filled, draw a random value on $[0, 1)$ and compare to $group_proportion$ to determine whether the household will be 1 or 2\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Set parameters\\ngrid_size = 20\\ngroup_proportion = 0.25\\ndensity = 0.5\\n\\n# Create the space and activate random cells\\nspace = numpy.zeros((grid_size, grid_size), dtype=numpy.int8)\\n\\n# Now sample the agents.\\nfor row_id in range(grid_size):\\n    for col_id in range(grid_size):\\n        # Determine if this cell will be populated\\n        if numpy.random.random() <= density:\\n            # Determine this cell's initial group\\n            if numpy.random.random() <= group_proportion:\\n                cell_type = 1\\n            else:\\n                cell_type = 2\\n            \\n            # Set the space\\n            space[row_id, col_id] = cell_type\\n        \\n# Now show the space\\nf = plt.figure()\\np = plt.pcolor(space, snap=True)\\nc = plt.colorbar()\",\"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_Classification\\/03.0 - TF Classification Model - DNN Wide & Deep + Train_And_Evaluate + Dataset + TFRecords.ipynb\\\".\\nThe first task is:\\nd. Run the experiment via train_and_evaluate\\nCan you write Python code for it?\\n\",\"targets\":\"\\nif not RESUME_TRAINING:\\n    print(\\\"Removing previous artifacts...\\\")\\n    shutil.rmtree(model_dir, ignore_errors=True)\\nelse:\\n    print(\\\"Resuming training...\\\") \\n\\n    \\ntf.logging.set_verbosity(tf.logging.INFO)\\n\\ntime_start = datetime.utcnow() \\nprint(\\\"Experiment started at {}\\\".format(time_start.strftime(\\\"%H:%M:%S\\\")))\\nprint(\\\".......................................\\\") \\n\\nestimator = create_estimator(run_config, hparams, True)\\n\\ntf.estimator.train_and_evaluate(\\n    estimator=estimator,\\n    train_spec=train_spec, \\n    eval_spec=eval_spec\\n)\\n\\ntime_end = datetime.utcnow() \\nprint(\\\".......................................\\\")\\nprint(\\\"Experiment finished at {}\\\".format(time_end.strftime(\\\"%H:%M:%S\\\")))\\nprint(\\\"\\\")\\ntime_elapsed = time_end - time_start\\nprint(\\\"Experiment elapsed time: {} seconds\\\".format(time_elapsed.total_seconds()))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"By day:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Plot\\ndaily_counts.index = ['Mon', 'Tues', 'Wed', 'Thurs', 'Fri', 'Sat', 'Sun']\\ndaily_counts['counts'].plot(title='Daily tweet counts', figsize=(12, 8), legend=True)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Capture image from the camera\\n\",\"targets\":\"ImageRecorder(stream=camera)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"3 Frequency\\nA frequency plot is a graph that shows the pattern in a set of data by plotting how often particular values of a measure occur. They often take the form of an histogram or a box plot.\\nReproduce the plots with the following three libraries, which provide high-level declarative syntax for statistical visualization as well as a convenient interface to pandas:\\n* Seaborn is a statistical visualization library based on matplotlib. It provides a high-level interface for drawing attractive statistical graphics. Its advantage is that you can modify the produced plots with matplotlib, so you loose nothing.\\n* ggplot is a (partial) port of the popular ggplot2 for R. It has his roots in the influencial book the grammar of graphics. Convenient if you know ggplot2 already.\\n* Vega is a declarative format for statistical visualization based on D3.js, a low-level javascript library for interactive visualization. Vincent (discontinued) and altair are Python libraries to vega. Altair is quite new and does not provide all the needed functionality yet, but it is promising !\\nHints:\\n* Seaborn, look at distplot() and boxplot().\\n* ggplot, we are interested by the geom_histogram geometry.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport seaborn as sns\\nimport os\\ndf = sns.load_dataset('iris', data_home=os.path.join('..', 'data'))\\n\\nfig, axes = plt.subplots(1, 2, figsize=(15, 5))\\n\\n# Your code for Seaborn: distplot() and boxplot().\\n\\nimport ggplot\\n\\n# Your code for ggplot.\\n\\nimport altair\\n\\n# altair.Chart(df).mark_bar(opacity=.75).encode(\\n#     x=...,\\n#     y=...,\\n#     color=...\\n# )\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"3.2.1 Stack 3 - Encoder Layer 3 => Decoder layer 2\\n\",\"targets\":\"with tf.variable_scope(\\\"Encoder\\\"):\\n    s3_enc_l3_act = tf.layers.dense(\\n        inputs=tf.stop_gradient(s2_dec_noisy_input),\\n        units=2000,\\n        activation=tf.nn.relu,\\n        kernel_initializer=tf.contrib.layers.xavier_initializer(seed=RANDOM_SEED),\\n        name=\\\"FC_3\\\",\\n    )\\n\\nwith tf.variable_scope(\\\"Decoder\\\"):\\n    s3_dec_noisy_input = tf.layers.dropout(inputs=s3_enc_l3_act, rate=0.2, seed=RANDOM_SEED, training=tf_apply_dropout)\\n    s3_dec_l2_act = tf.layers.dense(\\n        inputs=s3_dec_noisy_input,\\n        units=500,\\n        activation=tf.nn.relu,\\n        kernel_initializer=tf.contrib.layers.xavier_initializer(seed=RANDOM_SEED),\\n        name=\\\"FC_2\\\",\\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 \\\"EVI - 2018\\/EVI 04\\/Modulo1.ipynb\\\".\\nThe first task is:\\n<br>\\nadd_numbers es una función que toma dos números y los suma.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef add_numbers(x, y):\\n    return x + y\\n\\nadd_numbers(1, 2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"1. Data Acquisition\\nNOTE: In order to run the data acquisition process, one needs to obtain a token to connect to the Facebook Graph API. This token needs to be saved in a credentials file (by default credentials.ini in the current directory).\\nWe collect data from nine famous Facebook pages actively publishing articles related to the US elections:\\n\\nMainstream pages: Politico, CNN and ABC News Politics,\\nPro-democrate pages: The Other 98%, Addicting Info and Occupy Democrats,\\nPro-republican pages: Eagle Rising, Right Wing News and Freedom Daily.\\n\\nEach collected post includes the name of the page in addition to:\\n* the post id post_id,\\n* the URL of the post post_url, \\n* the time created_time when the post was created , \\n* the type of post type (i.e. status, link, video, photo), \\n* the text message of the post, \\n* the number of times the post was shared share_count,\\n* the number of times the post received a reaction reaction_count,\\n* the number of times the post was commented comment_count.\\n1.1 Facebook Web Scraper\\nTo have better flexibility on the scraping process, we collect data using the low-level approach with the requests library. The code of the scraper FacebookScraper, as well as all the code corresponding to the data collection part, is contained in the acquisition module.\\nThe FacebookScraper takes an iterable of Features which represents the fields we want to query on the Facebook Graph API and provide a convenient way to query, clean and save the raw data into a well-formatted pandas.DataFrame. \\nParameters\\nDefine the parameters for the web scraper:\\n* Credential file where your token is located\\n* List of the pages to scrape\\n* Date range over which we want to collect data\\n* Fields to query\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Credential file containing the Facebook authentication token\\ncredentials_file = 'credentials.ini'\\n\\n# List of pages to scrape\\npage_list = ['ABCNewsPolitics', 'cnnpolitics', 'politico', \\n             'AddictingInfoOrg', 'OccupyDemocrats', 'TheOther98', \\n             'FreedomDailyNews', 'OfficialRightWingNews', 'theEagleisRising']\\n\\n# Define the date range to scrape\\nstart_date = '2016\\/01\\/01'\\nend_date = '2016\\/12\\/05'\\n\\n# Define the fields to query\\nfield_list = [\\n    Feature('id', name='post_id'),\\n    Feature('permalink_url', name='post_url'),\\n    Feature('link'),\\n    Feature('created_time'),\\n    Feature('type'),\\n    Feature('message'),\\n    Feature('description'),\\n    Feature('picture'),\\n    Feature('status_type'),\\n    Feature('caption'),\\n    Feature('reactions.limit(0).summary(1)', \\n            formatter=lambda data: data.get('reactions', {'summary':{'total_count':0}})['summary']['total_count'], \\n            name='reaction_count'),\\n    Feature('comments.limit(0).summary(1)', \\n            formatter=lambda data: data.get('comments', {'summary':{'total_count':0}})['summary']['total_count'], \\n            name='comment_count'),\\n    Feature('shares', \\n            formatter=lambda data: data.get('shares', {'count': 0})['count'],\\n            name='share_count')\\n]\\n\\nprint('We collect data corresponding to fields:', ', '.join([f.fbquery for f in field_list]))\\nprint('from the Facebook pages: ', ', '.join(page_list))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<span style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">עיגול<\\/span>\\n<p style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\n    אפשר גם לעגל מספרים בעזרת הפונקציה <code>round<\\/code>: \\n<\\/p>\\n\",\"targets\":\"number = 5.9\\nround(number)\\n\\nnumbers = [6, 3.1415, 0.9, -0.9, 0.5, -0.5]\\nfor number in numbers:\\n    print(f\\\"round({number:>6}) = {round(number)}\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"1. Upload the model artefacts to Google Cloud Storage bucket\\n\",\"targets\":\"%%bash\\n\\ngsutil -m rm -r gs:\\/\\/${BUCKET}\\/tf-model-optimisation\\n\\n%%bash\\n\\nsaved_models_base=models\\/mnist\\/cnn_classifier\\/export\\/\\nsaved_model_dir=${saved_models_base}$(ls ${saved_models_base} | tail -n 1)\\n\\necho ${saved_model_dir}\\n\\ngsutil -m cp -r ${saved_model_dir} gs:\\/\\/${BUCKET}\\/tf-model-optimisation\\/original\\n\\n%%bash\\n\\nsaved_models_base=models\\/mnist\\/cnn_classifier\\/export\\/\\nsaved_model_dir=${saved_models_base}$(ls ${saved_models_base} | tail -n 1)\\/optimised\\n\\necho ${saved_model_dir}\\n\\ngsutil -m cp -r ${saved_model_dir} gs:\\/\\/${BUCKET}\\/tf-model-optimisation\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# create the data in case you skipped the previous exercise\\n\\n# a helper function to create the sine train set that can also add noise to the data\\ndef noisy_sine_train_data(noise=None):\\n    x_train = np.linspace(0, 6, 10).reshape((-1, 1))\\n    y_train = np.sin(x_train)\\n    \\n    # If fixed, set the random seed so that the next call of the\\n    # random function always returns the same result\\n    if noise == 'fixed':\\n        np.random.seed(1)\\n    \\n    x_train += np.random.randn(len(x_train)).reshape((-1, 1)) \\/ 5\\n    \\n    return x_train, y_train\\n\\ndef sine_test_data():\\n    x_test = 0.5 + np.arange(6).reshape((-1, 1))\\n    y_test = np.sin(x_test)\\n    return x_test, y_test\\n\\nx_train, y_train = noisy_sine_train_data(noise='fixed')\\n\\n# we randomly pick 3 data points to get a nice validation set\\ntrain_i = [0, 1, 3, 4, 6, 7, 9]\\nval_i = [2, 5, 8]\\n\\n# create the train and validation sets\\nx_train_i = x_train[train_i, :]\\ny_train_i = y_train[train_i]\\nx_val_i = x_train[val_i, :]\\ny_val_i = y_train[val_i]\\n\\n### BEGIN SOLUTION\\npol_exp = sklearn.preprocessing.PolynomialFeatures(degree=4)\\n### END SOLUTION\\n# pol_exp = sklearn.preprocessing.PolynomialFeatures(degree= ? )\\n\\nmodel = sklearn.linear_model.LinearRegression()\\nmodel.fit(pol_exp.fit_transform(x_train_i), y_train_i)\\n\\n### BEGIN SOLUTION\\ntrain_score = model.score(pol_exp.fit_transform(x_train_i), y_train_i)\\nvalidation_score = model.score(pol_exp.fit_transform(x_val_i), y_val_i)\\n### END SOLUTION\\n# train_score = model.score( ? )\\n# validation_score = model.score( ? )\\n\\nprint(f'The R2 score of this model on the train set is: {train_score:.3f}')\\nprint(f'The R2 score of this model on the validation set is: {validation_score:.3f}')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n5. Over-fitting and Cross-Validation\\nWhat you have experienced above is called over-fitting and happens when your model learns the noise that is inherent in the data.\\nThis problem was caused because there were to many parameters in the model. So the model was too advanced so that it became capable of learning the noise in the data by heart. Reducing the number of parameters solves this problem. But how do you know how many parameters is optimal?\\n(Another way to solve this problem is to use more data. Because if there are more data points in the data and if there is more noise, your model isn't able to learn all that noise anymore and you get a better result. Since it's often not possible to gather more data we will not take this approach.)\\nIn the exercise above you had to set the number of polynomial functions to get a better result, but how can you estimate this in a reliable way without manually selection the optimal parameters?\\n5.1. Validation set\\nA common way to solve this problem is through the use of a validation set. This means that you use a subset of the training data to train your model on, and another subset of the training data to validate your parameters. Based on the score of your model on this validation set you can select the optimal parameter.\\nSo use this approach to select the best number of polynomials for the noisy sine function.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create a scalar variable with the initial value 3.\\nv = tf.contrib.eager.Variable([3])\\n\\n# Create a vector variable of shape [1, 4], with random initial values,\\n# sampled from a normal distribution with mean 1 and standard deviation 0.35.\\nw = tf.contrib.eager.Variable(tf.random_normal([1, 4], mean=1.0, stddev=0.35))\\n\\nprint(\\\"v:\\\", v.numpy())\\nprint(\\\"w:\\\", w.numpy())\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAn alternative solution would be to reshape a into a 6x1 matrix and b into a 1x3 matrix, resulting in a 6x3 matrix after multiplication.\\nVariables, Initialization and Assignment\\nSo far, all the operations we performed were on static values (tf.constant); calling numpy() always returned the same result. TensorFlow allows you to define Variable objects, whose values can be changed.\\nWhen creating a variable, you can set an initial value explicitly, or you can use an initializer (like a distribution):\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# 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    min = np.min(image_data)\\n    max = np.max(image_data)\\n    return .1 + ((image_data - min) * (.9 - .1)) \\/ (max - min)\\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, train_labels,...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<img src=\\\"image\\/Mean_Variance_Image.png\\\" style=\\\"height: 75%;width: 75%; position: relative; right: 5%\\\">\\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.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Aに対して行列積(np.dot)を行うと以下のように単位行列が作成されます。これにより正しく逆行列が計算されることがわかります。\\n\",\"targets\":\"np.dot?\\n\\nnp.dot(A,AA)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create a Spark DataFrame from Pandas:\\n\",\"targets\":\"spark_df = context.createDataFrame(pandas_df)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"16--numpy.ipynb\\\".\\nThe first task is:\\nYou can also create empty (uninitialized) arrays. What does the following produce?\\nCan you write Python code for it?\\n\",\"targets\":\"\\nA = np.empty ((3, 4)) # An empty 3 x 4 matrix\\nprint A\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"And here's the fraction of Group 1 that would be below the threshold, which I'll call the false negative rate.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnp.mean(sample2 < thresh)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As no new Structure is build, the num_sub_systems must be updated by hand.\\nOtherwise this happens automatically.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nS.num_sub_systems = 2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"And now for the actual package...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport wwdata as ww\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"1.2 Adding derived features\\nSimilarly to the previous notebook, you can add derived features to your dataset, as demonstrated in the example below.\\n\",\"targets\":\"# Add a column where the week is derived from the datetime column.\\ncalls['week'] = calls.index.map(lambda observation_timestamp: \\n                                observation_timestamp.week)\\n\\n# Display the head of the new dataset.\\ncalls.head(5)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"All the above results are very close to the b1 calculation results for the 57 cm reactor. So my question: how is the b1 diffusion coefficient calculated and how does it differ from calculation of DIFFCOEFF?\\nSerpent 1 and 2 results for the same input file are pretty much identical, which I suppose should be expected. However, the Serpent 2 result file does contain a lot more information.\\n3\\/9\\/17\\nAnalog estimator: score the physical interactions (fission, capture, etc.) or event sequences that are simulated during the calculation. Analog estimates are directly related to the simulation process.\\nNote: in general when the chain of equalities ends, that generally means I've reached a point where all arguments are generated via Monte Carlo analog or implicit estimates, e.g. none of the arguments are derived quantities, e.g. if I search in collectresults.c, their first hit will be on the RHS of an equality sign. \\nDefault calculation of $D$:\\n\\\\begin{equation}\\nD_g = \\\\frac{\\\\bar{r_g^2}}{6}\\\\ \\\\Sigma_{r,g}\\n\\\\end{equation}\\nwhere $\\\\bar{r_g^2}$ is the mean value of all scored square distances that neutrons have made within energy group $g$, which is an analog estimator. The starting points are the locations where neutrons have entered the group by fission or scattering from another (higher) energy group. The end points are the locations at which the neutrons are lost from the group either by absorption or scattering to another (lower) energy group.\\nLeakage calculation of $D$:\\n\\\\begin{equation}\\nD_g = \\\\frac{leak}{B_m^2}\\\\\\nB_m^2 = \\\\frac{k_{\\\\infty} - 1}{L_g^2}\\\\\\nL_g^2 = \\\\frac{\\\\bar{r_g^2}}{6}\\\\\\nk_{\\\\infty} = \\\\frac{src}{loss} = \\\\frac{\\\\Sigma_{g,f}\\\\bar{\\\\nu}}{\\\\Sigma_{g,f} + \\\\Sigma_{g,c} - \\\\Sigma_{n\\\\rightarrow n}}\\n\\\\end{equation}\\nwhere $leak$ comes directly from Monte Carlo scoring of neutrons exiting the simulation domain I believe.\\nP1 calculation of $D$:\\n\\\\begin{equation}\\nD_g = \\\\frac{1}{3\\\\Sigma_{g,tr}}\\\\\\n\\\\Sigma_{g,tr} = \\\\Sigma_{g,t} - \\\\Sigma_{g,s1}\\n\\\\end{equation}\\nB1 calculation of $D$ (note that this occurs in b1solver.c which is different from...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n40 * 20000\\n\\n(381.99 + 160.60) \\/ 4\\n\\n381.99 + 160.60\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Collect some data\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# we'll use data from a job that collected tweets about parenting\\ntweet_bodies = [body for body in open('tweet_bodies.txt')]\\n\\n# sanity checks\\nprint(len(tweet_bodies))\\n\\n# sanity checks\\nprint(tweet_bodies[:10])\\n\\n# lets do some quick deduplication\\nfrom duplicate_filter import duplicateFilter\\n\\n## set the similarity threshold at 90%\\ndup_filter = duplicateFilter(0.9)\\n\\ndeduped_tweet_bodies = []\\nfor id,tweet_body in enumerate(tweet_bodies):\\n    if not dup_filter.isDup(id,tweet_body):\\n        deduped_tweet_bodies.append(tweet_body)\\n\\npprint(deduped_tweet_bodies[:10])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"$\\\\implies$ Yay! It seems faster indeed!\\n\\n\\nNumba implementation\\nAs this blog post explains it, we can also try to use Numba in a notebook cell.\\n\",\"targets\":\"from numba import jit\\n\\n@jit(\\\"int32(boolean[:])\\\")\\ndef lempel_ziv_complexity_numba_x(binary_sequence):\\n    \\\"\\\"\\\"Lempel-Ziv complexity for a binary sequence, in Python code using numba.jit() for automatic speedup (hopefully).\\\"\\\"\\\"\\n    u, v, w = 0, 1, 1\\n    v_max = 1\\n    length = len(binary_sequence)\\n    complexity = 1\\n    while True:\\n        if binary_sequence[u + v - 1] == binary_sequence[w + v - 1]:\\n            v += 1\\n            if w + v >= length:\\n                complexity += 1\\n                break\\n        else:\\n            if v > v_max:\\n                v_max = v\\n            u += 1\\n            if u == w:\\n                complexity += 1\\n                w += v_max\\n                if w > length:\\n                    break\\n                else:\\n                    u = 0\\n                    v = 1\\n                    v_max = 1\\n            else:\\n                v = 1\\n    return complexity\\n\\ndef str_to_numpy(s):\\n    \\\"\\\"\\\"str to np.array of bool\\\"\\\"\\\"\\n    return np.array([int(i) for i in s], dtype=np.bool)\\n\\ndef lempel_ziv_complexity_numba(s):\\n    return lempel_ziv_complexity_numba_x(str_to_numpy(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 \\\".ipynb_checkpoints\\/skill_cluster4-checkpoint.ipynb\\\".\\nThe first task is:\\nConsider only n-grams separately:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nunigram_occur = countOccur_ngram(n=1)\\nbigram_occur = countOccur_ngram(n=2)\\ntrigram_occur = countOccur_ngram(n=3)\\n\\noccur_df = pd.merge(unigram_occur, bigram_occur, on='job_id')\\noccur_df = pd.merge(occur_df, trigram_occur, on='job_id')\\n\\noccur_df['n_skill'] = occur_df['n_1gram'] + occur_df['n_2gram'] + occur_df['n_3gram']\\noccur_df.head()\\n\\nfrom my_util import *\\nn_skill_by_jd = pd.concat([quantile(occur_df['n_1gram']), quantile(occur_df['n_2gram']), quantile(occur_df['n_3gram'])])\\nn_skill_by_jd.index = ['n_unigram', 'n_bigram', 'n_trigram']\\nn_skill_by_jd\\n\\nn_skill_by_jd.to_csv(REPORT_DIR + 'skill_by_jd.csv')\\n\\ndef plot2(w=7, h=10):    \\n    fig = plt.figure(figsize=(w,h))\\n    for i in range(3):\\n        n = i+1\\n        plt.subplot(3, 1, n)\\n        plt.subplots_adjust(hspace=.25)\\n\\n        ngram_occur = occur_df['n_{}gram'.format(n)]\\n        m, bins, patches = plt.hist(x=ngram_occur, bins=np.unique(ngram_occur), align='left')\\n        plt.xlim(0, max(bins)+1)\\n\\n        if (n==3):\\n            plt.xticks(range(11))\\n    #     plt.title('{}-gram'.format(n))\\n        plt.xlabel('# {}-gram skills'.format(n), fontsize='large')\\n        plt.ylabel('# JDs', fontsize='large')\\n\\n    plt.show()\\n    return fig\\n\\nfig2 = plot2()\\nfig2.savefig(REPORT_DIR + 'n_skill_in_jd.pdf')\\nfig2.savefig(REPORT_DIR + 'n_skill_in_jd.jpeg')\\nplt.close(fig2)\",\"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\\/61_Registration_Introduction_Continued.ipynb\\\".\\nThe first task is:\\nVersion 2\\n<ul>\\n<li> Multi scale - specify both scale, and how much to smooth with respect to original image.<\\/li>\\n<li> Initial transformation modified in place, so in the end we have the same type of transformation in hand.<\\/li>\\n<\\/ul>\\nCan you write Python code for it?\\n\",\"targets\":\"\\nregistration_method = sitk.ImageRegistrationMethod()\\n\\nregistration_method.SetMetricAsMattesMutualInformation(numberOfHistogramBins=50)\\nregistration_method.SetMetricSamplingStrategy(registration_method.RANDOM)\\nregistration_method.SetMetricSamplingPercentage(0.01)\\n\\nregistration_method.SetInterpolator(sitk.sitkLinear)\\n\\nregistration_method.SetOptimizerAsGradientDescent(\\n    learningRate=1.0, numberOfIterations=100\\n)  # , estimateLearningRate=registration_method.EachIteration)\\nregistration_method.SetOptimizerScalesFromPhysicalShift()\\n\\nfinal_transform = sitk.Euler3DTransform(initial_transform)\\nregistration_method.SetInitialTransform(final_transform)\\nregistration_method.SetShrinkFactorsPerLevel(shrinkFactors=[4, 2, 1])\\nregistration_method.SetSmoothingSigmasPerLevel(smoothingSigmas=[2, 1, 0])\\nregistration_method.SmoothingSigmasAreSpecifiedInPhysicalUnitsOn()\\n\\nregistration_method.AddCommand(\\n    sitk.sitkStartEvent, registration_callbacks.metric_start_plot\\n)\\nregistration_method.AddCommand(\\n    sitk.sitkEndEvent, registration_callbacks.metric_end_plot\\n)\\nregistration_method.AddCommand(\\n    sitk.sitkMultiResolutionIterationEvent,\\n    registration_callbacks.metric_update_multires_iterations,\\n)\\nregistration_method.AddCommand(\\n    sitk.sitkIterationEvent,\\n    lambda: registration_callbacks.metric_plot_values(registration_method),\\n)\\n\\nregistration_method.Execute(\\n    sitk.Cast(fixed_image, sitk.sitkFloat32), sitk.Cast(moving_image, sitk.sitkFloat32)\\n)\\n\\nprint(\\n    f\\\"Optimizer's stopping condition, {registration_method.GetOptimizerStopConditionDescription()}\\\"\\n)\\nprint(f\\\"Final metric value: {registration_method.GetMetricValue()}\\\")\\n\\n# Save moving image after registration and view overlap using external viewer.\\nsave_transform_and_image(\\n    final_transform,\\n    fixed_image,\\n    moving_image,\\n    os.path.join(OUTPUT_DIR, \\\"finalAlignment-v2\\\"),\\n)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Avg adopters per seed comparison\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndraw_bars_comparison('Avg adopters per seeds', 'Avg adopters', np.array(get_avg_per_seed(eigen)+[(0, np.mean(eigen[:,1]))]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"13. Defina y llame una función que reciva de parametro una lista de listas y solucione el problema 8\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef max_list_of_lists(list_of_lists):\\n    size = len(list_of_lists)\\n    carpeta = list_of_lists[1]\\n    for i in range(size):\\n        if sum(list_of_lists[i]) > sum(carpeta):\\n            carpeta = list_of_lists[i]\\n    print(carpeta)\\n\\n# Implementar la función\\nlist_of_lists = [ [1,2,3], [4,5,6], [10,11,12], [7,8,9] ]\\nmax_list_of_lists (list_of_lists)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Bonus: reading a CSV file from Google Docs\\nIt used to be easy to anonymously read a public file directly from Google Docs, but now you need an API key. It's not too hard to set up, but you'll need to read some docs.\\nWhen you have an API key, put it here...\\n\",\"targets\":\"key = \\\"PUT YOUR KEY HERE\\\"\\n\\nimport json\\n\\nurl = \\\"https:\\/\\/sheets.googleapis.com\\/v4\\/spreadsheets\\/{id}\\/values\\/{sheet}\\\"\\n\\nmeta = {\\\"id\\\": \\\"1YlnEGT8uHpRllk7rjAgFFl8V6B5-kl02DBie11PjG9Q\\\",\\n        \\\"sheet\\\": \\\"Sheet1\\\"\\n        }\\nurl = url.format(**meta)\\n\\nparams = {\\\"key\\\": key}\\n\\nr = requests.get(url, params=params)\\nj = json.loads(r.text)['values']\\ndf = pd.DataFrame(j[1:], columns=j[0])\\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 \\\".ipynb_checkpoints\\/RNN_project-checkpoint.ipynb\\\".\\nThe first task is:\\n<a id='TODO_6'><\\/a>\\nWith your trained model try a few subsets of the complete text as input - note the length of each must be exactly equal to the window size.  For each subset us the function above to predict the next 100 characters that follow each input.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# TODO: choose an input sequence and use the prediction function in the previous Python cell to predict 100 characters following it\\n# get an appropriately sized chunk of characters from the text\\nstart_inds = []\\n\\n# load in weights\\nmodel.load_weights('model_weights\\/best_RNN_small_textdata_weights.hdf5')\\nfor s in start_inds:\\n    start_index = s\\n    input_chars = text[start_index: start_index + window_size]\\n\\n    # use the prediction function\\n    predict_input = predict_next_chars(model,input_chars,num_to_predict = 100)\\n\\n    # print out input characters\\n    print('------------------')\\n    input_line = 'input chars = ' + '\\\\n' +  input_chars + '\\\"' + '\\\\n'\\n    print(input_line)\\n\\n    # print out predicted characters\\n    line = 'predicted chars = ' + '\\\\n' +  predict_input + '\\\"' + '\\\\n'\\n    print(line)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\".loc may suffer from lower performance as compared to .iloc due to the possibility of needing to map the label values into locations.\\n\",\"targets\":\"# subset of first three rows\\nsubset = sp500[:3].copy()\\n# get the location of the Price column\\nprice_loc = sp500.columns.get_loc('Price')\\n# get the location of the MMM row\\nabt_row_loc = sp500.index.get_loc('ABT')\\n# change the price\\nsubset.iloc[abt_row_loc,price_loc] = 1000\\nsubset\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"4. Get template QC atlas from database\\nAvailable templates in Database:\\nMSMLS_HILICz150mm_Annotation20190824_Template_EMA_Unlabeled_Positive\\\\\\nMSMLS_HILICz150mm_Annotation20190824_Template_EMA_Unlabeled_Negative\\\\\\nMSMLS_HILICz150mm_Annotation20190824_Template_QCv3_Unlabeled_Positive\\\\\\nMSMLS_HILICz150mm_Annotation20190824_Template_QCv3_Unlabeled_Negative\\\\\\nMSMLS_HILICz150mm_Annotation20190824_Template_ISv5_Unlabeled_Positive\\\\\\nMSMLS_HILICz150mm_Annotation20190824_Template_ISv5_Unlabeled_Negative\\\\\\nMSMLS_HILICz150mm_Annotation20190824_Template_ISv5_13C15N_Positive\\\\\\nMSMLS_HILICz150mm_Annotation20190824_Template_ISv5_13C15N_Negative\\n\",\"targets\":\"#Atlas File Name \\nLCS = 'MSMLS' # Library Compound Set\\nCTY = 'HILICz150mm' # Chromatography\\nLR = 'Annotation20190824' # Library Run\\nRTS = 'Template' # RT space\\nCPD = 'QCv3' # Set of Compounds\\nLAB = 'Unlabeled' # Isolabeling\\nPOL = 'Positive' # Polarity\\n\\nQC_template_filename = \\\"_\\\".join((LCS,CTY,LR,RTS,CPD,LAB,POL))\\n\\natlases = metob.retrieve('Atlas',name=QC_template_filename,\\n                         username='vrsingan')\\nnames = []\\nfor i,a in enumerate(atlases):\\n    print(i,a.name,pd.to_datetime(a.last_modified,unit='s'),len(a.compound_identifications))\\n\\n# #Alternatively use this block to create QC atlas from spreadsheet\\n# import datetime\\n#dp = reload(dp)\\n\\n# LCS = 'MSMLS' # Library Compound Set\\n# CTY = 'HILICz150mm' # Chromatography\\n# LR = 'Annotation20190824' # Library Run\\n# RTS = 'Template' # RT space\\n# CPD = 'QCv3' # Set of Compounds\\n# LAB = 'Unlabeled' # Isolabeling\\n# POL = 'Positive' # Polarity\\n# DT = datetime.datetime.strftime(datetime.datetime.now(),'%Y%m%d')\\n# QC_template_filename = \\\"_\\\".join((LCS,CTY,LR,RTS,CPD,LAB,POL,DT))\\n\\n#myAtlas = dp.make_atlas_from_spreadsheet('\\/global\\/project\\/projectdirs\\/metatlas\\/projects\\/1_TemplateAtlases\\/TemplateAtlas_HILICz150mm_Annotation20190824_QCv3_Unlabeled_Positive.csv',\\n#                                       QC_template_filename,\\n#                                        filetype='csv',\\n#                                        sheetname='',\\n#                                        polarity = 'positive',\\n#                                        store=True,\\n#                                       mz_tolerance = 20)\\n#atlases = dp.get_metatlas_atlas(name=QC_template_filename,do_print = True,most_recent=True)\\n\\nmyAtlas = atlases[-1]\\natlas_df = ma_data.make_atlas_df(myAtlas)\\natlas_df['label'] = [cid.name for cid in myAtlas.compound_identifications]\\nprint myAtlas.name\\nprint myAtlas.username\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"But that shouldn't actually blow your mind. Based on our discussion before, you can probably guess that the decorator notation is just shorthand for: \\nsay_bye = verbose( say_bye )\\nOne place where this shorthand can come in particularly handy is when you need to stack a bunch of decorators. In place of nested decorators like this:\\npython\\nmy_func = do_thing_a( add_numbers( subtract( verify( my_func ))))\\nWe can write this as:\\npython\\n@do_thing_a\\n@add_numbers\\n@subtract\\n@verify\\ndef my_func():\\n    # something useful happens here\\nNote that the order matters!\\n\\nOk, thank you, please come again.\\nTHE END AGAIN\\n\\nOk, final round, I promise. \\nAppendix\\nThis is material that I originally intended to include in this RST (because it's relevant), but ultimately cut for clarity. You can come back and revisit it any time.\\nScopes and namespaces\\nRoughly speaking, scope and namespace are the reason you can type some code (like variable_1 = 'dog') and then transparently use variable_1 later in your code. Sounds obvious, but easy to take for granted!\\nThe concepts of scope and namespace in Python are pretty interesting and complex. Some time when you're bored and want to learn some details, have a read of this nice explainer or the official docs on the Python Execution Model. \\nA short way to think about them is the following:\\n\\nA namespace is a mapping from (variable) names to values; think about it like a Python dictionary, where our code can look up the keys (the variable names) and then use the corresponding values. You will generally have many namespaces in your code, they are usually nested (sort of like an onion), and they can even have identical keys (variable names). \\nThe scope (at a particular location in the code) defines in which namespace we look for variables (dictionary keys) when our code is executing.\\n\\nWhile this RST isn't explicitly about scope, understanding these concepts will make it easier to read the code later on. Let's look at some examples.\\nThere are two built-in functions that can aid in exploring the namespace...\\n\",\"targets\":\"# -c option starts a new interpreter session in a subshell and evaluates the code in quotes. \\n#  here, we just assign the value 3 to the variable x and print the global namespace\\n! python -c 'x=3; print( globals() )'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Abstract syntax trees\\nThis is made possible because siuba represents lazy expressions with abstract syntax trees.\\nFast grouped operations and SQL queries are just the beginning. This allows people to produce a whole range of interesting tools!\\nSiuba's lazy expressions consist of a Symbolic and Call class.\\nSymbolic is used to quickly create lazy expressions.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# ASTs for transforming\\nfrom siuba.siu import Symbolic, Call, strip_symbolic\\n\\n_ = Symbolic()\\n\\nsym = _.a.mean() + _[\\\"b\\\"]\\nsym\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Crear un arreglo de 10 unos\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnp.ones(10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"D\\nIn this question, you'll write a function acount_lines that performs the same operation as before, except in the case that the output file already exists: in this case, you'll append the line count to the file instead of overwriting it, thus preserving any existing previous line counts.\\nEach new appended line count should be on its own line in the output file. You may need to manually insert newline characters, which are a backslash followed by the letter n: \\\\n\\nYour function should return True on success, and False if an error occurred.\\nNOTE: Your function should be able to handle errors gracefully! If an error occurs when trying to read from the file or write to the output file, your function should return False.\\n\",\"targets\":\"if os.path.exists(\\\"q1data\\/out_again.txt\\\"):\\n    os.remove(\\\"q1data\\/out_again.txt\\\")\\n\\nassert acount_lines(\\\"q1data\\/file1.txt\\\", \\\"q1data\\/out_again.txt\\\")\\nassert os.path.exists(\\\"q1data\\/out_again.txt\\\")\\nassert int(open(\\\"q1data\\/out_again.txt\\\", \\\"r\\\").read()) == 3\\n\\nassert acount_lines(\\\"q1data\\/file2.txt\\\", \\\"q1data\\/out_again.txt\\\")\\nassert os.path.exists(\\\"q1data\\/out_again.txt\\\")\\nassert int(\\\"\\\".join(open(\\\"q1data\\/out_again.txt\\\", \\\"r\\\").read().split(\\\"\\\\n\\\"))) == 34\\n\\nr1 = None\\ntry:\\n    r1 = acount_lines(\\\"yet\\/another\\/nonexistent\\/path.txt\\\", \\\"meaningless\\\")\\nexcept:\\n    assert False\\nelse:\\n    assert not r1\\n\\nr2 = None\\ntry:\\n    r2 = acount_lines(\\\"q1data\\/file2.txt\\\", \\\"\\/this\\/should\\/throw\\/an\\/error.txt\\\")\\nexcept:\\n    assert False\\nelse:\\n    assert not r2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"!ls -lh data\\n\\nimport numpy as np\\nfrom keras.preprocessing.image import ImageDataGenerator\\nfrom keras.models import Sequential\\nfrom keras.layers import Dropout, Flatten, Dense\\nfrom keras import applications\\n\\n# dimensions of our images.\\nimg_width, img_height = 150, 150\\n\\ntrain_data_dir = 'data\\/train'\\nvalidation_data_dir = 'data\\/validation'\\nnb_train_samples = 2000\\nnb_validation_samples = 800\\nepochs = 50\\nbatch_size = 16\\n\\n# build the VGG16 network\\nmodel = applications.VGG16(include_top=False, weights='imagenet')\\n\\nmodel.summary()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThis script goes along the blog post\\n\\\"Building powerful image classification models using very little data\\\"\\nfrom blog.keras.io.\\nIt uses data that can be downloaded at:\\nhttps:\\/\\/www.kaggle.com\\/c\\/dogs-vs-cats\\/data\\nIn our setup, we:\\n- created a data\\/ folder\\n- created train\\/ and validation\\/ subfolders inside data\\/\\n- created cats\\/ and dogs\\/ subfolders inside train\\/ and validation\\/\\n- put the cat pictures index 0-999 in data\\/train\\/cats\\n- put the cat pictures index 1000-1400 in data\\/validation\\/cats\\n- put the dogs pictures index 12500-13499 in data\\/train\\/dogs\\n- put the dog pictures index 13500-13900 in data\\/validation\\/dogs\\nSo that we have 1000 training examples for each class, and 400 validation examples for each class.\\nIn summary, this is our directory structure:\\ndata\\/\\n    train\\/\\n        dogs\\/\\n            dog001.jpg\\n            dog002.jpg\\n            ...\\n        cats\\/\\n            cat001.jpg\\n            cat002.jpg\\n            ...\\n    validation\\/\\n        dogs\\/\\n            dog001.jpg\\n            dog002.jpg\\n            ...\\n        cats\\/\\n            cat001.jpg\\n            cat002.jpg\\n            ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Construct the reward array R and the transition probability array Q:\\n\",\"targets\":\"# Number of actions; 0: stay put, 1: new job, 2: new life\\nm = 3\\n\\n# Reward and transition probability arrays\\nR = np.empty((n, m))\\nQ = np.zeros((n, m, n))\\n\\n# Stay put\\nR[:, 0] = theta[s_indices2d[:, 0]] + epsilon[s_indices2d[:, 1]]\\nQ[np.arange(n), 0, np.arange(n)] = 1\\n\\n# New job\\nR[:, 1] = theta[s_indices2d[:, 0]] + G_mean\\nfor i in range(N):\\n    Q[i*N:(i+1)*N, 1, i*N:(i+1)*N] = G_probs\\n\\n# New life\\nR[:, 2] = F_mean + G_mean\\nQ[:, 2] = F_probs.reshape(N, 1).dot(G_probs.reshape(1, N)).ravel()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<font color='red'>Вопрос 6 (2 балла).<\\/font> Постройте новый признак – BMI (Body Mass Index). Для этого надо вес в килограммах поделить на квадрат роста в метрах. Нормальными считаются значения BMI от 18.5 до 25. Выберите верные утверждения.\\n<font color='red'>Утверждения:<\\/font>\\n- Медианный BMI по выборке превышает норму\\n- У женщин в среднем BMI ниже, чем у мужчин\\n- У здоровых в среднем BMI выше, чем у больных\\n- В сегменте здоровых и непьющих мужчин в среднем BMI ближе к норме, чем в сегменте здоровых и непьющих женщин\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndf['BMI'] = df.weight \\/ ((df.height \\/ 100) ** 2)\\nprint(\\\"median: \\\" + str(df.BMI.median()))\\nprint(\\\"women mean: \\\" + str(df[df.gender == 1].BMI.mean()))\\nprint(\\\"men mean: \\\" + str(df[df.gender == 2].BMI.mean()))\\nprint(\\\"healty mean: \\\" + str(df[df.cardio == 0].BMI.mean()))\\nprint(\\\"sick mean: \\\" + str(df[df.cardio == 1].BMI.mean()))\\nprint(\\\"teetotal healthy men mean: \\\" + str(df[(df.gender == 2) & (df.alco == 0) & (df.cardio == 0)].BMI.mean()))\\nprint(\\\"teetotal healthy women mean: \\\" + str(df[(df.gender == 1) & (df.alco == 0) & (df.cardio == 0)].BMI.mean()))\",\"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 ML Semcomp\\/semcomp17_ml\\/.ipynb_checkpoints\\/semcomp17_ml_answer-checkpoint.ipynb\\\".\\nThe first task is:\\nNow we will perform gradient descent update procedure according to the following formula:\\n$$W = W - k\\\\frac{\\\\partial L}{\\\\partial W}$$\\nHere we use fixed number of iterations and learning rate.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n\\\"\\\"\\\"step 4: gradient descent - update loop\\\"\\\"\\\"\\nnp.random.seed(0)\\nW = np.random.rand(1,X_train.shape[0]).astype(np.float32)   #W has size 1xD, randomly initialised\\nk = 1e-8                                #learning rate\\nniters = 160                            #number of training iterations\\n\\n#visualisation settings\\nvis_interval = niters\\/50\\nloss_collections = []\\nplt.close()\\nplt.ion()\\nfig = plt.figure(1,figsize=(16, 4))\\naxis_loss = fig.add_subplot(131)\\naxis_data = fig.add_subplot(132)\\nfor i in xrange(niters):\\n    Y_train = F_Regression(X_train,W)               #compute hypothesis function aka. predicted values\\n    loss = Loss_Regression(Y_train, Z_train)         #compute loss\\n    dLdW = dLdW_Regression(X_train, Y_train, Z_train) #compute gradient\\n    W = W - k*dLdW                            #update\\n    loss_collections.append(loss)\\n    if (i+1)% vis_interval == 0:\\n        ml_utils.plot_loss(axis_loss, range(i+1),loss_collections, \\\"loss = \\\" + str(loss))\\n        ml_utils.plot_scatter_and_line(axis_data, X_train, Z_train, W, \\\"iter #\\\" + str(i))\\n        fig.canvas.draw()\\nprint \\\"Learned parameters \\\", W.squeeze()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Beam search decoding\\n\",\"targets\":\"# Set up beam search.\\nbeam_decoder = Search(\\n    trax.models.Reformer, model_weights,\\n    beam_size=4,\\n    alpha=0.6,  # For length normalization, set to 0.6 following Vaswani et al.\\n    eos_id=1,  # The stop token has id 1 in the vocabulary we use.\\n    max_decode_len=146,\\n    )\\n\\npred_ids = []\\npreds = []\\nBATCH_SIZE = 1024\\nfor start in range(0, input_ids.shape[0], BATCH_SIZE):\\n  print(start, '\\/', input_ids.shape[0], flush=True)\\n  batch = input_ids[start:start+BATCH_SIZE]\\n  seqs, scores = beam_decoder.decode(batch, batch_size=BATCH_SIZE)\\n  # Select highest scoring output.\\n  batch_pred_ids = seqs[:, -1]\\n  pred_ids.append(batch_pred_ids)\\n  preds.extend([\\n      tokenizer.decode(pred.tolist(), strip_extraneous=True)\\n      for pred in batch_pred_ids\\n  ])\\n\\nbleu = sacrebleu.corpus_bleu(preds, [refs], lowercase=True, tokenize='intl')\\nprint(bleu)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Building the office structure\\nWe store the office points in a namedtuple called Point with the properties x and y to hold the co-ordinates.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom collections import namedtuple\\nPoint = namedtuple('Point', ('x', 'y'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# FINAL LOSS: 0.226 - Seq length 20, LR 0.001, Epochs 200\\n# FINAL LOSS: 0.141 - Seq length 20, LR 0.001, Epochs 250\\n# FINAL LOSS: 0.012 - Seq length 200, LR 0.01, Epochs 500 - Text generated equals to the data\\n\\n# Number of Epochs\\nnum_epochs = 250\\n# Batch Size\\nbatch_size = 64\\n# RNN Size\\nrnn_size = 256\\n# Embedding Dimension Size\\nembed_dim = 300\\n# Sequence Length\\nseq_length = 20\\n# Learning Rate\\nlearning_rate = 0.001\\n# Show stats for every n number of batches\\nshow_every_n_batches = 50\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\nsave_dir = '.\\/save'\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\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 embed_dim to the size of the embedding.\\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.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Get the unique names of the original Macaulay2016 clusters\\ncluster_names = macaulay2016_metadata.cluster.unique()\\n# Sort them in alphabetical order so that they're in the order we want\\ncluster_names.sort()\\n\\n# Map the cluster name to an integer number\\ncluster_name_to_integer = dict(zip(cluster_names, range(len(cluster_names))))\\n\\npaper_cluster_integers = macaulay2016_metadata.cluster.map(cluster_name_to_integer)\\npaper_cluster_integers.head()\\n\\nmacaulay2016_palette = [macaulay2016_cluster_to_color_from_paper[x] for x in cluster_names]\\n\\nfrom sklearn.metrics import confusion_matrix\\n\\nconfusion = pd.DataFrame(confusion_matrix(paper_cluster_integers, labels), \\n                         index=cluster_names)\\nconfusion.index.name = 'Macaulay2016 Labels'\\nconfusion.columns.name = 'K-Means Predicted'\\n\\nconfusiongrid = sns.clustermap(confusion, annot=True, fmt='d', figsize=(4, 4),\\n               col_cluster=False, row_cluster=False, \\n               row_colors=macaulay2016_palette, col_colors=kmeans_palette)\\n\\n# rotate the ylabels to be horizontal instead of vertical\\nplt.setp(confusiongrid.ax_heatmap.get_yticklabels(), rotation=0);\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise 1\\nChange the number of clusters to 20 and use the \\\"husl\\\" palette for coloring\\nEvaluating clustering\\nHow do we evaluate the clusters that we found versus the clusters from the paper?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"3.4 Generating a Training Dataset\\nThe following code generates a training dataset (separated into positive and negative classes according to a random line in $\\\\mathcal{X}$) and plots it.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef plot_data(fig,plot_id,X,y=None,w_arr=None,my_x=None,title=None):\\n    ax = fig.add_subplot(plot_id)\\n    if y is None:\\n        ax.plot(X[:,1],X[:,2],'gx')\\n    else:\\n        ax.plot(X[y > 0,1],X[y > 0,2],'b+',label='Positive (+)')\\n        ax.plot(X[y < 0,1],X[y < 0,2],'ro',label='Negative (-)')\\n    ax.set_xlim(-1,1)\\n    ax.set_ylim(-1,1)\\n    ax.grid(True)\\n    if w_arr is not None:\\n        if isinstance(w_arr,list) is not True:\\n            w_arr=[w_arr]\\n        for i,w in enumerate(w_arr):\\n            if i==0:\\n                draw_line(ax,w,'g-',label='Theoretical')\\n            else:\\n                draw_line(ax,w,'g--')\\n    if my_x is not None:\\n        ax.plot([my_x[0]],[my_x[1]],'kx',markersize=10)\\n    if title is not None:\\n        ax.set_title(title)\\n    ax.legend(loc='best',frameon=True)\\n\\ndef create_dataset(N,make_plot=True,seed=None):\\n    X = generate_data(N,seed=seed)\\n    w_theoretical = get_random_line()\\n    y = get_hypothesis(X,w_theoretical)\\n    if make_plot is True:\\n        fig = plt.figure(figsize=(7,5))\\n        plot_data(fig,111,X,y,w_theoretical,title=\\\"Initial Dataset\\\")\\n    return X,y,w_theoretical\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"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\":\"I am working on the file \\\"Data Science From Scratch\\/7 - Hypothesis And Inference.ipynb\\\".\\nThe first task is:\\nAssuming a normal distribution, we conclude that we are 95% confident that the interval below includes the true $p$:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnormal_two_sided_bounds(0.95, mu, sigma)\",\"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\":\"\\nInstruct the notebook to draw plot graphics inline:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"MBA_S17\\/Oliveira_CrimeRentNYC.ipynb\\\".\\nThe first task is:\\nMerge Crime and Precinct Data\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Merge the two Dataframes to include Zipcode\\n\\nCombo = pd.merge(Crime, Precinct,          # left and right df's\\n                 how='inner',              # Inner Merge \\n                 left_on='Precinct',       # link with this variable\\/column \\n                 right_on='Precinct',      # link with this variable\\/column\\n                indicator = True)\\n\\nCombo.dtypes\\n\\nCombo.head()\\n\\n# Update Crime df with data from Combo and remove indicator\\n\\nCrime = Combo [['Crime', 'YTD_Current', 'YTD_Prior', 'Precinct', 'Zip', 'borough','Neighborhood']]\\n\\nCrime.head()\",\"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.toplevel.radiative_forcings.greenhouse_gases.N2O.provision')  \\n\\n# PROPERTY VALUE(S): \\n# Set as follows: DOC.set_value(\\\"value\\\")  \\n# Valid Choices: \\n#      \\\"N\\/A\\\"  \\n#      \\\"M\\\"  \\n#      \\\"Y\\\"  \\n#      \\\"E\\\"  \\n#      \\\"ES\\\"  \\n#      \\\"C\\\"  \\n#      \\\"Other: [Please specify]\\\"  \\n# TODO - please enter value(s)\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n14. Radiative Forcings --&gt; Greenhouse Gases --&gt; N2O\\nNitrous oxide forcing\\n14.1. Provision\\nIs Required: TRUE&nbsp;&nbsp;&nbsp;&nbsp;Type: ENUM&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 1.N\\nHow this forcing agent is provided (e.g. via concentrations, emission precursors, prognostically derived, etc.)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Build the Neural Network\\nApply the functions you implemented above to:\\n- Apply embedding to input_data using your get_embed(input_data, vocab_size, embed_dim) function.\\n- Build RNN using cell and your build_rnn(cell, inputs) function.\\n- Apply a fully connected layer with a linear activation and vocab_size as the number of outputs.\\nReturn the logits and final state in the following tuple (Logits, FinalState)\\n\",\"targets\":\"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim=300):\\n    \\\"\\\"\\\"\\n    Build part of the neural network\\n    :param cell: RNN cell\\n    :param rnn_size: Size of rnns\\n    :param input_data: Input data\\n    :param vocab_size: Vocabulary size\\n    :param embed_dim: Number of embedding dimensions\\n    :return: Tuple (Logits, FinalState)\\n    \\\"\\\"\\\"\\n    embed =  get_embed(input_data, vocab_size, embed_dim = 300)\\n    # TODO: Imprplement Function\\n    output, final_state = build_rnn(cell, embed)\\n    predictions = tf.contrib.layers.fully_connected( output , vocab_size, activation_fn=None)\\n    return predictions , final_state\\n\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_build_nn(build_nn)\",\"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- Apply embedding to input_data using your get_embed(input_data, vocab_size, embed_dim) function.\\n- Build RNN using cell and your build_rnn(cell, inputs) function.\\n- Apply a fully connected layer with a linear activation and vocab_size as the number of outputs.\\nReturn the logits and final state in the following tuple (Logits, FinalState)\\n\",\"targets\":\"def build_nn(cell, rnn_size, input_data, vocab_size, embed_dim):\\n    \\\"\\\"\\\"\\n    Build part of the neural network\\n    :param cell: RNN cell\\n    :param rnn_size: Size of rnns\\n    :param input_data: Input data\\n    :param vocab_size: Vocabulary size\\n    :param embed_dim: Number of embedding dimensions\\n    :return: Tuple (Logits, FinalState)\\n    \\\"\\\"\\\"\\n    embeddings = get_embed(input_data, vocab_size, embed_dim)\\n    output, final_state = build_rnn(cell, embeddings)\\n    logits = tf.contrib.layers.fully_connected(output, vocab_size, activation_fn = None,\\n                                              weights_initializer=tf.truncated_normal_initializer(stddev=1\\/np.sqrt(2)),\\n                                              biases_initializer=tf.zeros_initializer())\\n    return logits, final_state\\n\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_build_nn(build_nn)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Copia_de_Copia_de_Preprocesamiento_y_Red_test.ipynb\\\".\\nThe first task is:\\nCargar base de datos\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Cargando base de datos Alerce.\\ndata = pd.read_pickle('\\/content\\/drive\\/My Drive\\/Supernova\\/ALERCE_stamps.pkl') # Base de datos original\\n#data = pd.read_pickle('\\/content\\/drive\\/My Drive\\/Supernova\\/ALERCE_stamps_1k.pkl') # Base de datos reducida\\n\\nimgs = data['images'] # Lista de 31727 imagenes\\nlabels = data['labels'] # Lista de 31727 labels\\n\\nimg_0 = imgs[0] # Primera imagen de imgs, ndarray 63x63, 3 canales\\nlabel_0 = labels[0] # Primer label, entero\\n\\nnp.shape(imgs)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Add attributes for supplementary edges\\n\",\"targets\":\"for e in g.edges(data=True):\\n    way_id = e[2].get('id').split('-')[0]\\n    if way_id in edge_ids_to_add:\\n        g_t.add_edge(e[0], e[1], **e[2])\\n        g_t.add_node(e[0], lat=g.node[e[0]]['lat'], lon=g.node[e[0]]['lon'])\\n        g_t.add_node(e[1], lat=g.node[e[1]]['lat'], lon=g.node[e[1]]['lon'])\\n    if way_id in edge_ids_to_remove:\\n        if g_t.has_edge(e[0], e[1]):\\n            g_t.remove_edge(e[0], e[1])\\n            \\nfor n in nx.isolates(g_t.copy()):\\n    g_t.remove_node(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 \\\"14\\/Homework-14-Ronga.ipynb\\\".\\nThe first task is:\\nOkay, it's far too big to even look at. Let's try to get a list of features from a new CountVectorizer that only takes the top 100 words.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ncount_vectorizer = CountVectorizer(stop_words='english', max_features=100)\\nX = count_vectorizer.fit_transform(speeches_df['content'])\\nX\\n\\npd.DataFrame(X.toarray(), columns=count_vectorizer.get_feature_names()).head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# get input \\ntest1 = '{}'     # 1 group, score 1 \\ntest2 = '{{{}}}' # 3 group \\ntest3 = '{{},{}}' # 3 group \\ntest4 = '{{{},{},{{}}}}' # 3 group \\ntest5 = '{<a>,<a>,<a>,<a>}' # 3 group \\ntest6 = '{{<ab>},{<ab>},{<ab>},{<ab>}}' # 3 group \\ntest7 = '{{<!!>},{<!!>},{<!!>},{<!!>}}' \\ntest8 = '{{<a!>},{<a!>},{<a!>},{<ab>}}' \\npuzzle =  open('day09.txt', 'r').read()   # Read as a string\\n\\n# Loop through the string counting the nest while ignoring the garbage along the way \\nscore = 0\\nopengroups = 0 \\nprev = ''                   # This is a hack for the '!', fix later todo \\nstream = puzzle \\nisgarbage = False \\nfor index, value in enumerate(stream):\\n    if prev == '!':\\n        prev = ''\\n    elif value == '!':\\n        prev = '!'\\n    elif value == '{' and isgarbage == False:\\n        opengroups += 1\\n        score = score + opengroups        # todo check this \\n    elif value == '}' and isgarbage == False:\\n        opengroups -= 1 \\n    elif value == '<' and isgarbage == False:\\n        isgarbage = True \\n    elif value == '>': \\n        isgarbage = False \\nprint(\\\"Open groups (should be 0) = \\\", opengroups)\\nprint(\\\"Total groups = \\\", score)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWhat I learned  \\n* I always forget about range to create a list of numbers \\n* next % size\\n* I don't understand numpy take or warp \\n* You can format a hex number with format(the number, the format you want) '02x' says make sure it is in two digits \\nAdvent of Code Day 9\\n Advent of Code Day 9 - Part 1  A large stream blocks your path. According to the locals, it's not safe to cross the stream at the moment because it's full of garbage. You look down at the stream; rather than water, you discover that it's a stream of characters.\\nYou sit for a while and record part of the stream (your puzzle input). The characters represent groups - sequences that begin with { and end with }. Within a group, there are zero or more other things, separated by commas: either another group or garbage. Since groups can contain other groups, a } only closes the most-recently-opened unclosed group - that is, they are nestable. Your puzzle input represents a single, large group which itself contains many smaller ones.\\nSometimes, instead of a group, you will find garbage. Garbage begins with < and ends with >. Between those angle brackets, almost any character can appear, including { and }. Within garbage, < has no special meaning.\\nIn a futile attempt to clean up the garbage, some program has canceled some of the characters within it using !: inside garbage, any character that comes after ! should be ignored, including <, >, and even another !.\\nYou don't see any characters that deviate from these rules. Outside garbage, you only find well-formed groups, and garbage always terminates according to the rules above.\\nHere are some self-contained pieces of garbage:\\n<>, empty garbage.\\n<random characters>, garbage containing random characters.\\n<<<<>, because the extra < are ignored.\\n<{!>}>, because the first > is canceled.\\n<!--!-->\\n, because the second ! is canceled, allowing the > to terminate the garbage.\\n<!--!!-->\\n\\n, because the second ! and the first > are canceled.\\n<{o\\\"i!a,<{i<a>, which ends at the first >.\\nHere are some examples of whole...\",\"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\\/quantopian_research_public\\/notebooks\\/lectures\\/Position_Concentration_Risk\\/notebook.ipynb\\\".\\nThe first task is:\\nFinal Point\\nBe invested in as many uncorrelated assets as possible. In finance this is known as diversification. If you have a pricing model, price everything and invest accordingly. This concept is explained in the Long-Short Equity Lecture.\\nCapital Constraints\\nBecause of transaction costs, you need to have certain minimum amounts of capital to invest in large numbers of assets. Therefore sometimes you are unable to invest in hundreds or thousands. In this case you should still try to maximize your portfolio size, keeping in mind that if you have a portfolio of size 20, you can still find 20 relatively uncorrelated assets and that's better than nothing.\\nNow Let's Explain with Math Rather Than Pictures\\nOne of the key aspects of modern portfolio theory is that by combining multiple assets into a portfolio, you can reduce the entire package's overall risk. Since we represent the volatility of an asset by its standard deviation, we can easily show this mathematically.\\nSay that we have two assets in a portfolio, $S_1$ and $S_2$, with weights $\\\\omega_1$ and $\\\\omega_2$ such that $\\\\omega_1 + \\\\omega_2 = 1$. Call the portfolio $P$ and say that $S_1$ and $S_2$ have mean and standard deviation $\\\\mu_1, \\\\sigma_1$ and $\\\\mu_2, \\\\sigma_2$ respectively. We can calculate the value of $P$ easily.\\n$$ P = \\\\omega_1 S_1 + \\\\omega_2 S_2 $$\\nNow we set $\\\\mu_P$ as the return of the portfolio $P$. It is simple to calculate the expected return of this portfolio:\\n$$ E[\\\\mu_P] = E[\\\\omega_1 \\\\mu_1 + \\\\omega_2 \\\\mu_2] = \\\\omega_1 E[\\\\mu_1] + \\\\omega_2 E[\\\\mu_2] $$\\nAs you can see, the expected return of the overall portfolio can be directly determined using the expected returns of the assets in the portfolio as well as their associated weights. Similarly, we can use these same characteristics to determine the overall risk of the portfolio, $\\\\sigma_p$. First, we calculate the variance of the portfolio, $\\\\sigma_p^2 = VAR[P]$. Then we say that the correlation between $S_1$ and $S_2$ is $COR[S_1,S_2] = \\\\frac{COV[S_1,S_2]}{\\\\sigma_1\\\\sigma_2} = \\\\rho_{12}$....\\nCan you write Python code for it?\\n\",\"targets\":\"\\nstocks = np.array([100, 75])\\nmean_returns = np.array([4, 6])\\n\\nr_12 = 0.20\\ncov_12 = r_12 * 0.05 * 0.08\\ncovariance_matrix = np.array([[0.05**2,cov_12],[cov_12,0.08**2]])\\n\\nweights = np.array([0.7, 0.3])\\n\\nP = np.dot(weights, stocks.T)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%R -i workDir\\n\\ninFile = paste(c(workDir, 'target_genome_index.txt'), collapse='\\/')\\n\\ntbl.target = read.delim(inFile, sep='\\\\t', header=F)\\ncolnames(tbl.target) = c('OTUId', 'genome_file', 'genome_ID', 'X', 'Y', 'Z')\\ntbl.target = tbl.target %>% distinct(OTUId)\\n\\n\\ncat('Number of target OTUs: ', tbl.target$OTUId %>% unique %>% length, '\\\\n')\\ncat('----------\\\\n')\\ntbl.target %>% head(n=3)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nGetting list of target taxa\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Authenticate your GCP account\\nIf you are using AI Platform Notebooks, your environment is already\\nauthenticated. Skip this step.\\nIf you are using Colab, run the cell below and follow the instructions\\nwhen prompted to authenticate your account via oAuth.\\nOtherwise, follow these steps:\\n\\n\\nIn the GCP Console, go to the Create service account key\\n   page.\\n\\n\\nFrom the Service account drop-down list, select New service account.\\n\\n\\nIn the Service account name field, enter a name.\\n\\n\\nFrom the Role drop-down list, select\\n   Machine Learning Engine > AI Platform Admin and\\n   Storage > Storage Object Admin.\\n\\n\\nClick Create. A JSON file that contains your key downloads to your\\nlocal environment.\\n\\n\\nEnter the path to your service account key as the\\nGOOGLE_APPLICATION_CREDENTIALS variable in the cell below and run the cell.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport sys\\n\\n# If you are running this notebook in Colab, run this cell and follow the\\n# instructions to authenticate your GCP account. This provides access to your\\n# Cloud Storage bucket and lets you submit training jobs and prediction\\n# requests.\\n\\nif 'google.colab' in sys.modules:\\n  from google.colab import auth as google_auth\\n  google_auth.authenticate_user()\\n\\n# If you are running this notebook locally, replace the string below with the\\n# path to your service account key and run this cell to authenticate your GCP\\n# account.\\nelse:\\n  %env GOOGLE_APPLICATION_CREDENTIALS ''\",\"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.13\\/_downloads\\/plot_read_inverse.ipynb\\\".\\nThe first task is:\\nShow result on 3D source space\\nCan you write Python code for it?\\n\",\"targets\":\"\\nlh_points = inv['src'][0]['rr']\\nlh_faces = inv['src'][0]['use_tris']\\nrh_points = inv['src'][1]['rr']\\nrh_faces = inv['src'][1]['use_tris']\\nfrom mayavi import mlab  # noqa\\n\\nmlab.figure(size=(600, 600), bgcolor=(0, 0, 0))\\nmesh = mlab.triangular_mesh(lh_points[:, 0], lh_points[:, 1], lh_points[:, 2],\\n                            lh_faces, colormap='RdBu')\\nmesh.module_manager.scalar_lut_manager.reverse_lut = True\\n\\nmesh = mlab.triangular_mesh(rh_points[:, 0], rh_points[:, 1], rh_points[:, 2],\\n                            rh_faces, colormap='RdBu')\\nmesh.module_manager.scalar_lut_manager.reverse_lut = True\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Constructing and estimating the model\\nThe next step is to formulate the econometric model that we want to use for forecasting. In this case, we will use an AR(1) model via the SARIMAX class in statsmodels.\\nAfter constructing the model, we need to estimate its parameters. This is done using the fit method. The summary method produces several convenient tables showing the results.\\n\",\"targets\":\"# Construct the model\\nmod = sm.tsa.SARIMAX(endog, order=(1, 0, 0), trend='c')\\n# Estimate the parameters\\nres = mod.fit()\\n\\nprint(res.summary())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<h2>Preprocessing Text<\\/h2>\\n\\n<p> After looking at our raw text, we know that there are a number of textual attributes that we will need to address before we can ultimately represent our text as quantified features. Using some built in string functions, we can address the character encoding and mixed capitalization.\\n\",\"targets\":\"article[:500].decode('utf-8').lower()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"3.2. KSEA in detail\\nIn the following, we show in detail the computations that are carried out inside the provided functions. Let us concentrate on a single condition (60 minutes after stimulation with prostaglandin E2) and a single kinase (CDK1).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndata_condition = data_fc['60min'].copy()\\n\\np_values = data_p_value['60min']\\n\\nkinase = 'CDK1'\\n\\nsubstrates = adj_matrix[kinase].replace(0, np.nan).dropna().index\\n\\ndetected_p_sites = data_fc.index\\n\\nintersect = list(set(substrates).intersection(detected_p_sites))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<div class=\\\"alert alert-info\\\">\\nThere are many other vectorized computations that you can do on NumPy arrays, including multiplication (<code>np.prod<\\/code>), mean (<code>np.mean<\\/code>), and variance (<code>np.var<\\/code>). They all act essentially the same way as <code>np.sum<\\/code> -- give the function an array, and it computes the relevant function across all the elements in the array.\\n<\\/div>\\n\\nExercise: Euclidean distance (2 points)\\nRecall that the Euclidean distance $d$ is given by the following equation:\\n$$\\nd(a, b) = \\\\sqrt{\\\\sum_{i=1}^N (a_i - b_i) ^ 2}\\n$$\\nIn NumPy, this is a fairly simple computation because we can rely on array computations and the np.sum function to do all the heavy lifting for us.\\n<div class=\\\"alert alert-success\\\">\\nComplete the function <code>euclidean_distance<\\/code> below to compute $d(a,b)$, as given by the equation above. Note that you can compute the square root using <code>np.sqrt<\\/code>.\\n<\\/div>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef euclidean_distance(a, b):\\n    \\\"\\\"\\\"Computes the Euclidean distance between a and b.\\n    \\n    Hint: your solution can be done in a single line of code!\\n    \\n    Parameters\\n    ----------\\n    a, b : numpy arrays or scalars with the same size\\n    \\n    Returns\\n    -------\\n    the Euclidean distance between a and b\\n    \\n    \\\"\\\"\\\"\\n    ### BEGIN SOLUTION\\n    return np.sqrt(np.sum((a - b) ** 2))\\n    ### END SOLUTION\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# load model without top layer\\nn_images_train=500\\nn_images_test=500\\ninput_image_shape = (3,224,224)\\ntrain_features, train_labels,train_files, \\\\\\ntest_features, test_labels, test_files = dvc.training_test_datasets(all_files,\\n                                                                    n_images_train,n_images_test,\\n                                                                    input_image_shape)\\n\\n# load_img from keras.preprocessing loads the images in [0,255] scale\\ntrain_features = preprocess_input(train_features)\\ntest_features = preprocess_input(test_features)\\n\\nfrom keras.models import Model\\nbase_model = VGG16(weights='imagenet')\\nmodel = Model(input=base_model.input, output=base_model.get_layer('fc2').output)\\n\\nprint(\\\"Predicting train images\\\")\\ntrain_features_cnn = model.predict(train_features,verbose=1)\\nprint(\\\"Predicting test images\\\")\\ntest_features_cnn = model.predict(test_features,verbose=1)\\n\\ntrain_features_cnn.shape\\n\\nfrom sklearn import svm\\nfrom sklearn.model_selection import GridSearchCV\\n\\ntuned_parameters = {'kernel': ['linear'],\\n                     'C': [1, 10, 100, 1000]}\\n\\nclf = GridSearchCV(svm.SVC(C=1), tuned_parameters, cv=5,n_jobs=7)\\nclf.fit(train_features_cnn, train_labels)\\n\\nclf.best_estimator_\\n\\nprint(\\\"Train score: {}\\\".format(clf.score(train_features_cnn,train_labels)))\\nprint(\\\"Test score: {}\\\".format(clf.score(test_features_cnn,test_labels)))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUsing pretrained CNN as feature extractors\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%sql\\nselect year, count(*) from SeattleCrimeIncidents\\ngroup by year;\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nHow many crimes per year?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"$||\\\\mathbf{w}||2 = \\\\sqrt{\\\\sum{j=1}^D w_j^2}$\\n\",\"targets\":\"def norm_2(x):\\n    c=0\\n    for i in range(len(x)):\\n        c += x[i]**2\\n    return math.sqrt(c)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%matplotlib inline\\nimport numpy as np\\nfrom scipy import linalg\\nimport matplotlib.pyplot as plt\\nimport matplotlib as mpl\\n\\nfrom sklearn import mixture\\n\\n\\ndef plot_gmm(X, models, n_components, covariance_type='diag',\\n            figsize=(10, 20), suptitle=None, xlabel=None, ylabel=None):\\n    color_iter = ['r', 'g', 'b', 'c', 'm', 'y', 'k', 'gray', 'pink', 'lime']\\n    plt.figure(figsize=figsize)\\n    plt.suptitle(suptitle, fontsize=20)\\n\\n    for i, model in enumerate(models):\\n        mm = getattr(mixture, model)(n_components=n_components,\\n                                     covariance_type=covariance_type)\\n        mm.fit(X_pos_qid)\\n        Y = mm.predict(X_pos_qid)\\n\\n        plt.subplot(len(models), 1, 1 + i)\\n        for i, color in enumerate(color_iter):\\n            plt.scatter(X_pos_qid[Y == i, 0], X_pos_qid[Y == i, 1], .7, color=color)\\n        plt.title(model, fontsize=15)\\n        plt.xlabel(xlabel, fontsize=12)\\n        plt.ylabel(ylabel, fontsize=12)\\n        plt.grid()\\n\\n    plt.show()\\n\\nfrom collections import UserDict\\nimport numpy as np\\n\\n\\nclass DictDict(UserDict):\\n    def __init__(self, bd):\\n        UserDict.__init__(self)\\n        self._set_bd(bd)\\n        \\n    def sub_keys(self):\\n        return self[list(self.keys())[0]].keys()\\n            \\n    def select(self, sub_keys):\\n        vals = []\\n        for key in self:\\n            vals.append([self[key][sub_key] for sub_key in sub_keys])\\n        return np.array(vals)\\n    \\n    def sub_append(self, sub_key, values):\\n        for index, key in enumerate(self):\\n            self[key][sub_key] = values[index]\\n\\n    \\nclass Users(DictDict):\\n    def _set_bd(self, bd):\\n        pos_uid, _, _ = _get_pos(bd['train'], sign_val=None)\\n        for key in pos_uid:\\n            u = np.array(pos_uid[key])\\n            ave_pos_uid = sum(abs(u)) \\/ float(len(u))\\n            acc_ratio_uid = len(u[u > 0]) \\/ float(len(u))\\n            self[key] = {'ave_pos_uid': ave_pos_uid,\\n                         'acc_ratio_uid': acc_ratio_uid}\\n\\n            \\nclass Questions(DictDict):\\n    def _set_bd(self,...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nGMM\\nClassifying questions\\nfeatures: avg_pos, accuracy rate\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%set_cell_height 300\\n\\n# Specify the model.\\nmodel_1 = tfdf.keras.RandomForestModel(num_trees=30)\\n\\n# Train the model.\\nmodel_1.fit(x=train_ds)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFinaly, train and evaluate the model as usual. TF-DF  automatically detects multi-valued categorical features as categorical-set.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"P3:_creating_customer_segments\\/.ipynb_checkpoints\\/customer_segments-checkpoint.ipynb\\\".\\nThe first task is:\\nImplementation: Dimensionality Reduction\\nWhen using principal component analysis, one of the main goals is to reduce the dimensionality of the data — in effect, reducing the complexity of the problem. Dimensionality reduction comes at a cost: Fewer dimensions used implies less of the total variance in the data is being explained. Because of this, the cumulative explained variance ratio is extremely important for knowing how many dimensions are necessary for the problem. Additionally, if a signifiant amount of variance is explained by only two or three dimensions, the reduced data can be visualized afterwards.\\nIn the code block below, you will need to implement the following:\\n - Assign the results of fitting PCA in two dimensions with good_data to pca.\\n - Apply a PCA transformation of good_data using pca.transform, and assign the reuslts to reduced_data.\\n - Apply a PCA transformation of the sample log-data log_samples using pca.transform, and assign the results to pca_samples.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# TODO: Fit PCA to the good data using only two dimensions\\npca = PCA(n_components=2)\\npca.fit(good_data)\\n\\n# TODO: Apply a PCA transformation the good data\\nreduced_data = pca.transform(good_data)\\n\\n# TODO: Apply a PCA transformation to the sample log-data\\npca_samples = pca.transform(log_samples)\\n\\n# Create a DataFrame for the reduced data\\nreduced_data = pd.DataFrame(reduced_data, columns = ['Dimension 1', 'Dimension 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 \\\"Cal3-PythonGraphes.ipynb\\\".\\nThe first task is:\\n2.16 Graphes de contour\\nColormaps and contour figures are useful for plotting functions of two variables. In most of these functions we will use a colormap to encode one dimension of the data. There are a number of predefined colormaps. It is relatively straightforward to define custom colormaps. For a list of pre-defined colormaps, see: http:\\/\\/www.scipy.org\\/Cookbook\\/Matplotlib\\/Show_colormaps\\nCan you write Python code for it?\\n\",\"targets\":\"\\nalpha = 0.7\\nphi_ext = 2 * np.pi * 0.5\\n\\ndef flux_qubit_potential(phi_m, phi_p):\\n    return 2 + alpha - 2 * np.cos(phi_p) * np.cos(phi_m) - alpha * np.cos(phi_ext - 2*phi_p)\\n\\nphi_m = np.linspace(0, 2*np.pi, 100)\\nphi_p = np.linspace(0, 2*np.pi, 100)\\nX,Y = np.meshgrid(phi_p, phi_m)\\nZ = flux_qubit_potential(X, Y).T\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# old name: process_data\\ndef transform_data(selected_columns, data):\\n    '''\\n    Apply log-transform and MinMaxScaler() to the selected data columns which are not fractions (frac_*)\\n    \\n    Parameters\\n    ==========\\n    selected_columns : list\\n        list of columns to leave in processed data\\n    data : pandas.DataFrame\\n        data to process (note that data should contain all selected_columns)\\n        \\n    Returns\\n    =======\\n    log_scaled_data : pandas.DataFrame\\n        log-transformed and scaled data selected by selected_columns\\n    '''\\n    \\n    data.reset_index(drop=True, inplace=True)\\n    log_data = data[selected_columns].copy()\\n    \\n    skewed = log_data.columns.tolist()\\n    skewed = [item for item in skewed if not item.startswith('frac_')]\\n    log_data[skewed] = log_data[skewed].apply(lambda x: np.log10(x + 1))\\n\\n    scaler = MinMaxScaler().fit(log_data)\\n    log_scaled_data = scaler.transform(log_data)\\n    log_scaled_data = pd.DataFrame(log_scaled_data, columns=log_data.columns)\\n    \\n    return log_scaled_data\\n\\ndef replace_group_numbers(best_preds):\\n    '''\\n    Replace group numbers in best_preds with sorting by group size \\n    (so that the largest group is 0, the second largest is 1 etc.)\\n    \\n    Parameters\\n    ==========\\n    best_preds : numpy array\\n        unsorted array of predictions\\n    \\n    Returns\\n    =======\\n    best_preds_sorted : numpy array\\n        sorted array of predictions\\n    '''\\n    \\n    pp = pd.DataFrame(best_preds, columns = [\\\"old_group\\\"])\\n    dict_pp = {item[0]: i for i, item in enumerate(Counter(best_preds).most_common())}\\n    pp['new_group'] = pp['old_group'].replace(dict_pp)\\n    best_preds_sorted = np.array(pp['new_group'])\\n    return best_preds_sorted\\n\\ndef kmeans(log_scaled_data):\\n    '''\\n    Apply KMeans clustering algorithm with 2 <= cluster_number <= 6 to log_scaled_data \\n    (transformed and scaled by transform_data() function)\\n    \\n    Parameters\\n    ==========\\n    log_scaled_data : pandas.DataFrame\\n        data log-transormed and MinMaxScaler()-ed for KMeans...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nClustering\\nWrite a new clustering algorithm that:\\n- starts from stud_data or its subset (with monotonic index)\\n- finds a 2-column set with the largest score (using KMeans) and renames it that 0 is the largest group, 1 is the second largest etc.\\n- returns index file (with indices 0, 1, ) that could be used for further analysis\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Alternatively, we can get a random value between 0 and 1 using random.random() and simply multiply it by 10 to achieve the same thing. There are cases where one method might be preferable over the other, so it is useful to know them both.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nrandom.random()*10\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"By combining Boolean operations, masking operations, and aggregates, we can very quickly answer these sorts of questions for our dataset.\\nAside: Using the Keywords and\\/or Versus the Operators &\\/|\\nOne common point of confusion is the difference between the keywords and and or on one hand, and the operators &amp; and | on the other hand.\\nWhen would you use one versus the other?\\nThe difference is this: and and or gauge the truth or falsehood of entire object, while &amp; and | refer to bits within each object.\\nWhen you use and or or, it's equivalent to asking Python to treat the object as a single Boolean entity.\\nIn Python, all nonzero integers will evaluate as True. Thus:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nbool(42), bool(0)\\n\\nbool(42 and 0)\\n\\nbool(42 or 0)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create a median composite\\n\",\"targets\":\"median_composite = landsat_ds.median('time').persist()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"1504_Seismic_petrophysics_1\\/Seismic_petrophysics_1.ipynb\\\".\\nThe first task is:\\nNotice that there is no gas_sand log (occurrence of gas sands) yet, as the insitu log did not record any gas sand. We will deal with that later.\\nI use the above flag logs to create the LFC log and store it into the logs DataFrame:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntemp_lfc = np.zeros(np.shape(logs.VSH))\\ntemp_lfc[brine_sand.values] = 1    # LFC will be 1 when ssb (brine sand flag) is True\\ntemp_lfc[oil_sand.values] = 2      # LFC will be 2 when sso (oil sand flag) is True\\ntemp_lfc[shale.values] = 4         # LFC will be 4 when sh (shale flag) is True\\nlogs['LFC'] = temp_lfc             # Copy the temporary log temp_lfc into the DataFrame with name `LFC`\\n\\nlogs.to_csv('qsiwell2_lfc.csv',index=False) # save the data for use in Part 2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#$HIDE_INPUT$\\ny = tunnel[\\\"NumVehicles\\\"]\\n\\nmodel = LinearRegression(fit_intercept=False)\\n_ = model.fit(X, y)\\n\\ny_pred = pd.Series(model.predict(X), index=y.index)\\nX_fore = dp.out_of_sample(steps=90)\\ny_fore = pd.Series(model.predict(X_fore), index=X_fore.index)\\n\\nax = y.plot(color='0.25', style='.', title=\\\"Tunnel Traffic - Seasonal Forecast\\\")\\nax = y_pred.plot(ax=ax, label=\\\"Seasonal\\\")\\nax = y_fore.plot(ax=ax, label=\\\"Seasonal Forecast\\\", color='C3')\\n_ = ax.legend()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWith our feature set created, we're ready to fit the model and make predictions. We'll add a 90-day forecast to see how our model extrapolates beyond the training data. The code here is the same as that in earlier lessons.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Add EPA emission factors for fossil fuels not included in the EIA file\\nhttps:\\/\\/www.epa.gov\\/sites\\/production\\/files\\/2015-07\\/documents\\/emission-factors_2014.pdf\\n- BFG (blast furnace gas)\\n- MSW (non-biomass portion)\\n- OG (other gas, assume fuel gas)\\nAdd zero values for all bio fuels. Still need to figure out what to do for synthetic gas from coal and petroleum...\\n\",\"targets\":\"ef.loc['BFG',:] = ['Blast Furnace Gas', 274.32, None , 'https:\\/\\/www.epa.gov\\/sites\\/production\\/files\\/2015-07\\/documents\\/emission-factors_2014.pdf']\\nef.loc['MSN',:] = ['Non-biomass Municipal Solid Waste', 90.7, 'Assume the same as MSW', 'https:\\/\\/www.epa.gov\\/sites\\/production\\/files\\/2015-07\\/documents\\/emission-factors_2014.pdf']\\n\\n# Use the bituminous coal factor for synthetic coal\\nef.loc['SC',:] = ['Synthetic Coal', 93.3, 'Use same factor as BIT and RC', None]\\n\\n# Use fuel gas for other gases\\nef.loc['OG', :] = ['Other gases', 59, 'Assume fuel gas', 'https:\\/\\/www.epa.gov\\/sites\\/production\\/files\\/2015-07\\/documents\\/emission-factors_2014.pdf']\\n\\n# Use BIT factor for synthetic gas from coal (SGC) and DFO for SGP\\n# The actual factors won't matter as much because we're going to use the EPA \\n# emission values. \\nef.loc['SGC', ['Fossil Factor', 'Notes']] = [93.3, 'Using BIT value. Likely not correct']\\nef.loc['SGP', ['Fossil Factor', 'Notes']] = [73.16, 'Using DFO value. Likely not correct']\\n\\nnon_fossil_fuels = ['AB', 'BLQ', 'LFG', 'MSB', 'NUC', 'OBG', 'OBL', 'OBS',\\n                    'OTH', 'PUR', 'SLW', 'SUN', 'WAT', 'WDL', 'WDS', 'WH', 'WND']\\n\\nfor fuel in non_fossil_fuels:\\n    ef.loc[fuel, ['Fossil Factor', 'Notes']] = [0, 'non-fossil fuel']\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Choose the vertical line on the right panel to create a vertical projection. Position it at $Q_y=0$. Click to the floppy disk to save projection to a text file. The result should look as shown below.\\n\",\"targets\":\"projfile = \\\"data\\/proj1.txt\\\"\\ndata = np.loadtxt(projfile)\\nplt.semilogy(data[:,0], data[:,1], color='r')\\nplt.xlabel(r'$Q_z$ (nm$^{-1}$)')\\nplt.ylabel('Intensity (a. u.)')\\nplt.title(r\\\"Vertical slice at $Q_y=0$ nm$^{-1}$\\\")\\nplt.xlim(0.0, 2.3);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# loss A\\n#    ||h(s) - a|^p - R|^q\\n# This is danabo's mode regression loss\\n\\np = 0.1\\nq = 1\\/P\\n# p = q = 2.0\\ndef loss(model, s, a, y):\\n  reg = tf.linalg.global_norm(model.trainable_variables)\\n  return tf.reduce_mean(tf.abs(-tf.abs(model(s)-a)**p - y)**q) + 0.003*reg\\n\\n# loss B\\n#    |h(s) - a|^p * exp(R\\/tau)\\n# This is one of Dale's surrogate loss, specifically dot-product loss.\\n\\np = 1.0\\ntau = 1\\/10.\\ndef loss(model, s, a, y):\\n  reg = tf.linalg.global_norm(model.trainable_variables)\\n  target = tf.cast(tf.exp(y\\/tau), tf.float32)\\n  return tf.reduce_mean(tf.abs(model(s)-a)**p * target) + 0.0005*reg\\n\\nnp.var(s)\\n\\n# Initialize model\\n\\ndevice_string = '\\/device:GPU:0'\\n# device_string = '\\/device:TPU:0'\\n# device_string = ''  # CPU\\n\\nwith tf.device(device_string):\\n  model(data[0])\\n  print(loss(model, *data).numpy())  # Initialize model\\n\\noptimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)\\n\\ndef sample_batch(batch_size, *args):\\n  assert args\\n  idx = np.random.choice(args[0].shape[0], batch_size)\\n  return tuple([arg[idx] for arg in args])\\n\\nfor i in range(10000):\\n  # batch = sample_batch(100, *data)\\n  batch = data\\n  optimizer.minimize(lambda: loss(model, *batch), model.trainable_variables)\\n  if i % 100 == 0:\\n    print(i, '\\\\t', loss(model, *data).numpy())\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWhat loss functions best recover the curve $f$ from our dataset?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Combine all the walkers into a single array of generated samples.  You could trim off some initial \\\"burn-in\\\" here, but I don't recommend it (see lecture notes):\\n\",\"targets\":\"samples = sampler.chain[:, :, :].reshape((-1, ndim))\\n\\nsamples.shape\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Converting Categorical Features\\nWe'll need to convert categorical features to dummy variables using pandas! Otherwise our machine learning algorithm won't be able to directly take in those features as inputs.\\n\",\"targets\":\"train.info()\\n\\nsex = pd.get_dummies(train['Sex'],drop_first=True)\\nembark = pd.get_dummies(train['Embarked'],drop_first=True)\\n\\ntrain.drop(['Sex','Embarked','Name','Ticket'],axis=1,inplace=True)\\n\\ntrain = pd.concat([train,sex,embark],axis=1)\\n\\ntrain.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#  df[['Company Name', 'TOV Category', 'Amount']].head()\\ndf.groupby(('Company Name', 'TOV Category')).sum().sort_values('Amount', ascending=False).head(10)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPayments by pharma companies by category\\nBreak down the above table by category, too. Again, this is only declared payments.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%R\\niris %>%\\ngroup_by(Species) %>%\\nsummarise(Sepal.Width.Avg = mean(Sepal.Width)) %>%\\narrange(Sepal.Width.Avg)\\n\\n%%R\\nlibrary(ggplot2)\\nggplot(data=iris, aes(x=Sepal.Length, y=Sepal.Width, color=Species)) + geom_point(size=3)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLe formatage de l'output n'est pas parfaitement identique à un notebook en R nativement\\n* bloc d'output est plus long\\n* headers pas en gras\\n* ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"(NILMTK imports the 'common metadata' from the NILM Metadata project, which includes a wide range of different category taxonomies)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnilmtk.global_meter_group.select_using_appliances(building=2, category='laundry appliances')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"01-Regression\\/LRaudio.ipynb\\\".\\nThe first task is:\\nEmbedding the audio file.\\nNote that this is not working directly in GitHub (I think all JavaScript is stripped out), fork it or download it to play the audio\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom IPython.display import Audio\\nAudio(\\\"..\\/outputs\\/OriginalTestClip.wav\\\")\",\"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 Jupyter Extensions Tutorial.ipynb\\\".\\nThe first task is:\\nNotice how the string constant was updated to contain two quotes when inserted into the SQL statement. This is done automatically by the %sql magic command, so there is no need to use the two single quotes when assigning a string to a variable. However, you must use the two single quotes when using constants in a SQL statement.\\nBuiltin Variables\\nThere are 5 predefined variables defined in the program:\\n\\ndatabase - The name of the database you are connected to\\nuid - The userid that you connected with\\nhostname = The IP address of the host system\\nport - The port number of the host system\\nmax - The maximum number of rows to return in an answer set\\n\\nTheses variables are all part of a structure called _settings. To retrieve a value, use the syntax:\\npython\\ndb = _settings['database']\\nThere are also 3 variables that contain information from the last SQL statement that was executed.\\n\\nsqlcode - SQLCODE from the last statement executed\\nsqlstate - SQLSTATE from the last statement executed\\nsqlerror - Full error message returned on last statement executed\\n\\nYou can access these variables directly in your code. The following code segment illustrates the use of the SQLCODE variable.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nempnos = ['000010','999999']\\nfor empno in empnos:\\n    ans1 = %sql -r SELECT SALARY FROM EMPLOYEE WHERE EMPNO = :empno\\n    if (sqlcode != 0):\\n        print(\\\"Employee \\\"+ empno + \\\" left the company!\\\")\\n    else:\\n        print(\\\"Employee \\\"+ empno + \\\" salary is \\\" + str(ans1[1][0]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Build a Distributed Random Forest (DRF) model with default settings\\n\\n# Import the function for DRF\\nfrom h2o.estimators.random_forest import H2ORandomForestEstimator\\n\\n# Set up DRF for regression\\n# Add a seed for reproducibility\\ndrf_default = H2ORandomForestEstimator(model_id = 'drf_default', seed = 1234)\\n\\n# Use .train() to build the model\\ndrf_default.train(x = features, \\n                  y = 'Survived', \\n                  training_frame = titanic_train)\\n\\n# Check the DRF model summary\\ndrf_default\\n\\n# Check the model performance on test dataset\\ndrf_default.model_performance(titanic_test)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<br>\\nDistributed Random Forest\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<img src='.\\/tables\\/Dorogokupets2007_Au.png'>\\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 = dorogokupets2007_au.cal_v(p, temp * np.ones_like(p), min_strain=0.6)\\nprint(1.-(v\\/v0))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Alternate Representations\\nmodf() takes a single floating point number and returns a tuple containing the fractional and whole number parts of the input value.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport math\\n\\nfor i in range(6):\\n    print '{}\\/2 = {}'.format(i, math.modf(i\\/2.0))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"4.4  For testuserid, once again, print out the ratings using the bizs list as before. How have they changed with respect to Question 2? Why might this be?\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n#your code here\\nprint \\\"for user\\\",usernamefromid(fulldf,testuserid), 'avg', fulldf[fulldf.user_id==testuserid].stars.mean() \\nfor i in bizs:\\n    print \\\"=========\\\"\\n    print biznamefromid(fulldf, i), i\\n    print rating(fulldf, dbfull, i, testuserid, k=7, reg=3.) \\n    u,a=get_other_ratings(i, testuserid, fulldf)\\n    print \\\"User Score:\\\",u,\\\"Avg score\\\",a\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Fit anamorphosis by changing, zmax, zmin, and extrapolation function\\nPCI, H, raw, zana, gauss, z, P, \\\\\\nraw_var, PCI_var, fig1, \\\\\\nzamin, zamax, yamin, yamax, \\\\\\nzpmin, zpmax, ypmin, ypmax = pygslib.nonlinear.anamor(\\n                 z = data['Z'], \\n                 w = data['Declustering Weight'], \\n                 zmin = data['Z'].min()-0.1, \\n                 zmax = data['Z'].max()+1,\\n                 zpmin = None,\\n                 zpmax = data['Z'].max()+1.5,\\n                 ymin=-2.9, ymax=2.9,\\n                 ndisc = 5000,\\n                 ltail=1, utail=4, ltpar=1, utpar=1.8, K=30)\\n\\nPCI\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nInteractive anamorphosis modeling\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"1.4.10\\n\",\"targets\":\"from image import file2image\\nfrom image import image2display\\nfrom plotting import plot\\nimg = file2image(\\\"img01.png\\\")\\n#image2display(img)\\nwidth = len(img[0])\\nheight = len(img)\\nlt = []\\n[[lt.append(x+(187*1j-y*1j)) for x in range(width) if sum(img[y][x])<360]for y in range(height)]\\nplot(lt,188)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Creating a DatetimeIndex on a Dataframe\\nMuch of the original motivation for writing pandas was for financial time series modeling. As a result, there are many efficiently implemented methods and conveniences built in the data structures. \\nMany of these depend on dataframe rows being addressed (indexed) with a time-like data type, which is exactly what the DatetimeIndex is for. \\nIf our data has some sort of timestamp in it, how do we convert it to an associated datetimeindex?\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nd = pd.read_csv('misc\\/small.csv', names=['date','value'])\\n\\nd.tail()\\n\\n# is 'date' a data-like data type?\\nd.dtypes\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<div id='ex' \\/>\\n\\nExamples of QR: Classic vs Modified Gram-Schmidt\\nBack to TOC\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.\\n# Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.\\n# Style: DIM, NORMAL, BRIGHT, RESET_ALL\\ntextQRClassic = lambda x: Style.BRIGHT+Fore.RED+x+Style.RESET_ALL\\ntextQRModified = lambda x: Style.BRIGHT+Fore.BLUE+x+Style.RESET_ALL\\ntextAnswer = lambda x: Back.BLACK+Fore.CYAN+x+Style.RESET_ALL\\n\\n# Example 4.16 from textbook.\\nd = 1e-10\\nA = np.array([[1,1,1],[d,0,0],[0,d,0],[0,0,d]])\\nprint(textBold('A: \\\\n'), A)\\n\\nQc,Rc = QR(A, type_gram_schmidt = 'classic')\\nQm,Rm = QR(A, type_gram_schmidt = 'modified')\\n\\n################################\\nprint(textBoldH('\\\\n What are the Q\\\\'s?'))\\nprint(textQRClassic('Qc: \\\\n'), Qc)\\nprint(textQRModified('Qm: \\\\n'), Qm)\\n\\n################################\\nprint(textBoldH('\\\\n Are truly orthogonal the q_i\\\\'s?'))\\nprint(textQRClassic('Qc.T*Qc: \\\\n'),np.dot(Qc.T,Qc))\\nprint(textQRClassic('||Qc.T*Qc-I_3||: '),np.linalg.norm(np.dot(Qc.T,Qc)-np.eye(3))) # Warning: We are just using the transpose since the matrices are real!\\nprint(textAnswer('Not really, since q2^T*q3 \\\\\\\\neq 0.'))\\n\\nprint(textQRModified('\\\\n Qm.T*Qm: \\\\n'),np.dot(Qm.T,Qm))\\nprint(np.linalg.norm(np.dot(Qm.T,Qm)-np.eye(3)))\\nprint(textQRModified('||Qm.T*Qm-I_3||: '),np.linalg.norm(np.dot(Qm.T,Qm)-np.eye(3)))\\nprint(textAnswer('This looks much better!'))\\n\\n################################\\nprint(textBoldH('\\\\n Do we recover A with each algorithm?'))\\nprint(textQRClassic('A-Qc*Rc: \\\\n'),A-np.dot(Qc,Rc))\\nprint(textQRClassic('||A-Qc*Rc||: '),np.linalg.norm(A-np.dot(Qc,Rc)))\\nprint(textAnswer('Yes!'))\\n\\nprint(textQRModified('\\\\n A-Qm*Rm: \\\\n'),A-np.dot(Qm,Rm))\\nprint(textQRModified('||A-Qm*Rm||: '),np.linalg.norm(A-np.dot(Qm,Rm)))\\nprint(textAnswer('Yes!'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Deep Learning.ai\\/Numpy - Understanding Backprop.ipynb\\\".\\nThe first task is:\\nCompute the loss\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Using cross - entropy loss\\n# Softmax loss = data loss + regularization loss\\n\\n# Study about the Softmax loss and how it works before seeing how it works \\n#in this case it could be intuitive\\nnum_examples = X.shape[0]\\n# get unnormalized probabilities\\nexp_scores = np.exp(scores)\\n# normalize them for each example\\n'''We now have an array probs of size [300 x 3], where each row now contains the class\\nprobabilities. In particular, since we’ve normalized them every row now sums to one. We \\ncan now query for the log probabilities assigned to the correct classes in each example:'''\\nprobs = exp_scores \\/ np.sum(exp_scores, axis=1 , keepdims=True)\\n# Calculating the correct_log probability \\n'''The array correct_logprobs is a 1D array of just the probabilities assigned to the\\ncorrect classes for each example. The full loss is then the average of these log \\nprobabilities and the regularization loss:'''\\ncorrect_logprobs = -np.log(probs[range(num_examples),y])\\n\\n\\n\\n# compute ths loss : average cross-entropy loss and regularization \\ndata_loss = np.sum(correct_logprobs)\\/ num_examples\\nreg_loss = 0.5*reg*np.sum(W*W)\\n\\n'''∂Li∂fk=pk−1(yi=k)\\n\\nNotice how elegant and simple this expression is. Suppose the probabilities we \\ncomputed were p = [0.2, 0.3, 0.5], and that the correct class was the middle\\none (with probability 0.3). According to this derivation the gradient on the \\nscores would be df = [0.2, -0.7, 0.5]. Recalling what the interpretation of the \\ngradient, we see that this result is highly intuitive: increasing the first or \\nlast element of the score vector f (the scores of the incorrect classes) leads to \\nan increased loss (due to the positive signs +0.2 and +0.5) - and increasing the\\nloss is bad, as expected. However, increasing the score of the correct class has\\nnegative influence on the loss. The gradient of -0.7 is telling us that increasing\\nthe correct class score would lead to a decrease of the loss Li, which makes sense.'''\\ndscores = probs \\ndscores[range(num_examples),y]-=1\\ndscores\\/=num_examples\\n\\ndW =...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Adicionais\\/derivada.ipynb\\\".\\nThe first task is:\\nPara avaliar a derivada em um ponto, por exemplo, para calcular $f'(1)$, digitamos:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndiff(f(x),x).subs(x,1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Batch normalization and initialization\\nWe will now run a small experiment to study the interaction of batch normalization and weight initialization.\\nThe first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnp.random.seed(231)\\n# Try training a very deep net with batchnorm\\nhidden_dims = [50, 50, 50, 50, 50, 50, 50]\\n\\nnum_train = 1000\\nsmall_data = {\\n  'X_train': data['X_train'][:num_train],\\n  'y_train': data['y_train'][:num_train],\\n  'X_val': data['X_val'],\\n  'y_val': data['y_val'],\\n}\\n\\nbn_solvers = {}\\nsolvers = {}\\nweight_scales = np.logspace(-4, 0, num=20)\\nfor i, weight_scale in enumerate(weight_scales):\\n  print('Running weight scale %d \\/ %d' % (i + 1, len(weight_scales)))\\n  bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=True)\\n  model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=False)\\n\\n  bn_solver = Solver(bn_model, small_data,\\n                  num_epochs=10, batch_size=50,\\n                  update_rule='adam',\\n                  optim_config={\\n                    'learning_rate': 1e-3,\\n                  },\\n                  verbose=False, print_every=200)\\n  bn_solver.train()\\n  bn_solvers[weight_scale] = bn_solver\\n\\n  solver = Solver(model, small_data,\\n                  num_epochs=10, batch_size=50,\\n                  update_rule='adam',\\n                  optim_config={\\n                    'learning_rate': 1e-3,\\n                  },\\n                  verbose=False, print_every=200)\\n  solver.train()\\n  solvers[weight_scale] = solver\\n\\n# Plot results of weight scale experiment\\nbest_train_accs, bn_best_train_accs = [], []\\nbest_val_accs, bn_best_val_accs = [], []\\nfinal_train_loss, bn_final_train_loss = [], []\\n\\nfor ws in weight_scales:\\n  best_train_accs.append(max(solvers[ws].train_acc_history))\\n  bn_best_train_accs.append(max(bn_solvers[ws].train_acc_history))\\n  \\n  best_val_accs.append(max(solvers[ws].val_acc_history))\\n  bn_best_val_accs.append(max(bn_solvers[ws].val_acc_history))\\n  \\n  final_train_loss.append(np.mean(solvers[ws].loss_history[-100:]))\\n  bn_final_train_loss.append(np.mean(bn_solvers[ws].loss_history[-100:]))\\n  \\nplt.subplot(3, 1, 1)\\nplt.title('Best val accuracy vs weight initialization scale')\\nplt.xlabel('Weight initialization...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"ModelingExamples2.ipynb\\\".\\nThe first task is:\\nQuestion\\nAre two given histograms drawn from the same distribution?\\n$[3,5,12,4]$\\n$[8, 14, 31, 14]$\\nVisualizing the Dirichlet Distribution\\n[http:\\/\\/blog.bogatron.net\\/blog\\/2014\\/02\\/02\\/visualizing-dirichlet-distributions\\/]\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%matplotlib inline\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\nimport matplotlib.tri as tri\\nfrom functools import reduce\\nfrom scipy.special import gammaln\\n\\ncorners = np.array([[0, 0], [1, 0], [0.5, 0.75**0.5]])\\ntriangle = tri.Triangulation(corners[:, 0], corners[:, 1])\\n\\nrefiner = tri.UniformTriRefiner(triangle)\\ntrimesh = refiner.refine_triangulation(subdiv=4)\\n\\n\\n# Mid-points of triangle sides opposite of each corner\\nmidpoints = [(corners[(i + 1) % 3] + corners[(i + 2) % 3]) \\/ 2.0 \\\\\\n             for i in range(3)]\\n\\ndef xy2bc(xy, tol=1.e-3):\\n    '''Converts 2D Cartesian coordinates to barycentric.'''\\n    s = [(corners[i] - midpoints[i]).dot(xy - midpoints[i]) \\/ 0.75 \\\\\\n         for i in range(3)]\\n    return np.clip(s, tol, 1.0 - tol)\\n\\nclass Dirichlet(object):\\n    def __init__(self, alpha):\\n        self._alpha = np.array(alpha)\\n        self._coef = gammaln(np.sum(self._alpha)) - np.sum(gammaln(self._alpha))\\n    def log_pdf(self, x):\\n        return self._coef + np.sum(np.log(x)*(self._alpha - 1)) \\n    def pdf(self, x):\\n        '''Returns pdf value for `x`.'''\\n        return np.exp(self.log_pdf(x))\\n        \\ndef draw_pdf_contours(dist, nlevels=200, subdiv=8, **kwargs):\\n\\n    refiner = tri.UniformTriRefiner(triangle)\\n    trimesh = refiner.refine_triangulation(subdiv=subdiv)\\n    pvals = [dist.pdf(xy2bc(xy)) for xy in zip(trimesh.x, trimesh.y)]\\n\\n    plt.tricontourf(trimesh, pvals, nlevels, **kwargs)\\n    plt.axis('equal')\\n    plt.xlim(0, 1)\\n    plt.ylim(0, 0.75**0.5)\\n    plt.axis('off')\\n\\ndraw_pdf_contours(Dirichlet([1, 3, 1]))\\n\\ndraw_pdf_contours(Dirichlet([1.99, 3.99, 10.99]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"And we can extract one part of a list using slicing:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfriend_list = ['John', 'Bob', 'Marry']\\nlist_with_fewer_friends = friend_list[:2]\\nprint(list_with_fewer_friends)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%bigquery\\nCREATE OR REPLACE MODEL\\n    babyweight.model_3\\n\\nTRANSFORM(\\n    weight_pounds,\\n    is_male,\\n    mother_age,\\n    plurality,\\n    gestation_weeks,\\n    ML.FEATURE_CROSS(\\n        STRUCT(\\n            is_male,\\n            ML.BUCKETIZE(\\n                mother_age,\\n                GENERATE_ARRAY(15, 45, 1)\\n            ) AS bucketed_mothers_age,\\n            plurality,\\n            ML.BUCKETIZE(\\n                gestation_weeks,\\n                GENERATE_ARRAY(17, 47, 1)\\n            ) AS bucketed_gestation_weeks\\n        )\\n    ) AS crossed\\n)\\n\\nOPTIONS (\\n    MODEL_TYPE=\\\"LINEAR_REG\\\",\\n    INPUT_LABEL_COLS=[\\\"weight_pounds\\\"],\\n    L2_REG=0.1,\\n    DATA_SPLIT_METHOD=\\\"NO_SPLIT\\\") AS\\n\\nSELECT\\n    *\\nFROM\\n    babyweight.babyweight_data_train\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nModel 3:  Apply the TRANSFORM clause\\nBefore we perform our prediction, we should encapsulate the entire feature set in a TRANSFORM clause. This way we can have the same transformations applied for training and prediction without modifying the queries.\\nLet's apply the TRANSFORM clause to the model_3 and run the query.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# %load _solutions\\/case4_air_quality_analysis34.py\\n\\n# %load _solutions\\/case4_air_quality_analysis35.py\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<div class=\\\"alert alert-success\\\">\\n\\n__EXERCISE 15__\\n\\nThe maximum daily, 8 hour mean, should be below 100 µg\\/m³. What is the number of exceedances of this limit for each year\\/station?\\n\\n<details><summary>Hints<\\/summary>\\n\\n- Have a look at the `rolling` method to perform moving window operations.\\n\\n<\\/details>\\n\\n<br>_Note:_\\nThis is not an actual limit for NO$_2$, but a nice exercise to introduce the `rolling` method. Other pollutans, such as 0$_3$ have actually such kind of limit values based on 8-hour means.\\n\\n<\\/div>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"4. Instantiate and Estimator with the Required Parameters\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nCHECKPOINT_STEPS=1000\\n\\nhparams  = tf.contrib.training.HParams(\\n    training_steps = 10000,\\n    periodicities = [200],\\n    input_window_size = 40,\\n    output_window_size=10,\\n    batch_size = 15,\\n    loss = tf.contrib.timeseries.ARModel.NORMAL_LIKELIHOOD_LOSS, # NORMAL_LIKELIHOOD_LOSS | SQUARED_LOSS\\n    hidden_units = None,\\n    learning_rate = 0.1\\n    \\n)\\n\\n\\nmodel_dir = 'trained_models\\/{}'.format(MODEL_NAME)\\n\\nrun_config = tf.estimator.RunConfig().replace(\\n    save_checkpoints_steps=CHECKPOINT_STEPS,\\n    tf_random_seed=19830610,\\n    model_dir=model_dir\\n)\\n                                             \\nprint(\\\"Model directory: {}\\\".format(run_config.model_dir))\\nprint(\\\"Hyper-parameters: {}\\\".format(hparams))\\nprint(\\\"\\\")\\n\\ntrain_input_fn = generate_input_fn(\\n    file_name=TRAIN_DATA_FILE,\\n    mode = tf.estimator.ModeKeys.TRAIN,\\n    batch_size=hparams.batch_size,\\n    windows_size = hparams.input_window_size + hparams.output_window_size\\n)\\n\\nestimator = create_estimator(run_config, hparams)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Matching structure (example): \\n# bnetza_id uba_id\\n# 1         1\\n# 2         1\\n# 3         1\\n# 4         2\\n# 5         2\\n\\n# Get relevant entries from the matchinglist and merge the corresponding \\n# UBA Data to the list.\\nmatchnt1= matchinglist[\\n    (matchinglist.duplicated(subset=['uba_id_string'], keep=False) == True)\\n    & (matchinglist.duplicated(subset=['ID BNetzA'], keep=False)== False)]\\nmatchnt1 = pd.merge(matchnt1, plantlist_uba,\\n                    left_on='uba_id_string', right_on='uba_id_string', how='left')\\nmatchnt1 = matchnt1.set_index('ID BNetzA')\\n\\n# Import BNetzA Capacities and CHP criterion into matchnt1 dataframe\\nplantlist_capacities = pd.DataFrame(plantlist[['capacity', 'chp']]).rename(\\n    columns={'capacity': 'capacity_bnetza', 'chp': 'chp_bnetza'})\\nmatchnt1 = pd.merge(matchnt1, plantlist_capacities,\\n                    left_index=True, right_index=True, how='left')\\n\\n# Get sum of BNetzA Capacitites for each UBA Index and merge into matchnt1 dataframe\\nplantlist_uba_capacitysum = pd.DataFrame(\\n    matchnt1.groupby('uba_id_string').sum()['capacity_bnetza']).rename(\\n        columns={'capacity_bnetza': 'capacity_bnetza_aggregate'})\\nmatchnt1 = pd.merge(matchnt1, plantlist_uba_capacitysum,\\n                    left_on='uba_id_string', right_index=True, how='left')\\n\\n# Scale UBA Capacities based BNetzA Data\\nmatchnt1['uba_capacity_scaled'] = (matchnt1['uba_capacity']\\n                                   * matchnt1['capacity_bnetza']\\n                                   \\/ matchnt1['capacity_bnetza_aggregate'])\\n\\n# determine sum of capacities with chp capability and add to matchnt1\\nplantlist_uba_chp_capacities = matchnt1[(matchnt1['chp_bnetza'] == 'yes')]\\nplantlist_uba_chp_capacitysum = pd.DataFrame(\\n    plantlist_uba_chp_capacities.groupby('uba_id_string')\\n    .sum()['capacity_bnetza']) \\nplantlist_uba_chp_capacitysum = plantlist_uba_chp_capacitysum.rename(\\n    columns={'capacity_bnetza': 'capacity_bnetza_with_chp'})\\n\\nmatchnt1 = pd.merge(matchnt1, plantlist_uba_chp_capacitysum,\\n                   ...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n7.2.2 case n-1\\nMatch multiple BNetza IDs to one UBA ID\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Daily\\/20150902_phoenix_bol_corrs.ipynb\\\".\\nThe first task is:\\nFor reference, at [Fe\\/H] = $-0.5$ dex, we have\\nTeff      logg   [Fe\\/H]  [a\\/Fe]         B           V           R           I\\n3000.00    5.00   -0.50    0.20        -6.533      -5.496      -4.424      -3.154\\nThe interpolation routine has seemingly handled the non-monotonic nature of the metallicity column, as all interpolate values lie between values at the two respective nodes.\\n\\nNow let's import an isochrone and calcuate colors for stellar models for comparison against MARCS bolometric corrections.\\nCan you write Python code for it?\\n\",\"targets\":\"\\niso = np.genfromtxt('\\/Users\\/grefe950\\/evolve\\/dmestar\\/iso\\/dmestar_00120.0myr_z+0.00_a+0.00_marcs.iso')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"*5.3 Write a function that takes three parameters. The third is a callable (function) that takes two parameters. The function should call its third parameter with the first two as parameters. If the third parameter is not specified the function should add the two arguments.\\nThis is very similar to the previous function but the third parameter is a function instead of a string.\\n\",\"targets\":\"# TODO def call_func(...)\\n\\ndef product(x, y):\\n    return x * y\\n\\nassert(call_func(3, 4, product) == 12)\\nassert(call_func(\\\"foo\\\", \\\"bar\\\") == \\\"foobar\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create a random forest classifier\\nclf = RandomForestClassifier(n_estimators=10000, random_state=0, n_jobs=-1)\\n\\n# Train the classifier\\nclf.fit(X_train, y_train)\\n\\n# Print the name and gini importance of each feature\\nfor feature in zip(feat_labels, clf.feature_importances_):\\n    print(feature)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTrain A Random Forest Classifier\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Check how the annotators did on internal gold questions\\n\",\"targets\":\"# Starting from batch three we have included internal gold questions for toxicity and constructiveness (20 each) with \\n# internal_gold_constructiveness flag True. In the code below, we examine to what extent the annotators agreed with \\n# these internal gold questions. \\n\\n# Get a subset dataframe with internal gold questions for constructiveness\\ninternal_gold_con_df = df[df['constructive_internal_gold'].notnull()].copy()\\n\\n# Call secret_gold_evaluation_constructiveness function from data_quality_analysis_functions\\nprint('Disagreement on constructiveness secret gold questions (%): ', secret_gold_evaluation_constructiveness(internal_gold_con_df))\\n\\n# Get a subset dataframe with internal gold questions for toxicity\\ninternal_gold_tox_df = df[df['crowd_toxicity_level_internal_gold'].notnull()].copy()\\n\\n# Call secret_gold_evaluation_toxicity function from data_quality_analysis_functions\\nprint('Disagreement on toxicity secret gold questions (%): ', secret_gold_evaluation_toxicity(internal_gold_tox_df))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create Data Frame\\n\",\"targets\":\"# Create feature matrix\\nX = np.array([[1, 2], \\n              [6, 3], \\n              [8, 4], \\n              [9, 5], \\n              [np.nan, 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 \\\"BAMM.101x\\/Web_scraping.ipynb\\\".\\nThe first task is:\\n<h3>get the value of the login token<\\/h3>\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef get_login_token(response):\\n    soup = BeautifulSoup(response.text, 'lxml')\\n    token = soup.find('input',{'name':\\\"wpLoginToken\\\"}).get('value')\\n    return token\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"As this plot (created entirely without MCMC!) shows, the MCMC method did well, but our estimate of the true parameters has become biased by the stochastic noise! You can test this by increasing the number of sample points, which increases the size of the noise sample, and reduces the bias.\\nFinally, we can look at the bit that really matters: The model predictions made from models with the parameters we found (a posterior predictive check). Thes can be plotted using the series() method.\\n\",\"targets\":\"fig, axes = pints.plot.series(chain, problem)\\n\\n# Customise the plot, and add the original, noise-free data\\nfig.set_size_inches(12,4.5)\\nplt.plot(times, org_values, c='orange', label='Noise-free data')\\nplt.legend()\\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 \\\"5-functions.ipynb\\\".\\nThe first task is:\\nthis is handy: \\n* if we want a function to work one way, but occasionally need it to do something else, we can allow people to pass a diff parameter when they need to but provide a default\\n\\nbelow example shows how python matches values to parameters:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef display(a=1, b=2, c=3):\\n    print('a:', a, 'b:', b, 'c:', c)\\n\\nprint('no parameters:')\\ndisplay()\\nprint('one parameter:')\\ndisplay(55)\\nprint('two parameters:')\\ndisplay(55, 66)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"## all Nans to white space\\nx = x.replace(np.nan, ' ', regex = True)\\nx = x.replace(np.nan, 'NaN', regex = True)\\n## convert to all floats\\nwith warnings.catch_warnings():\\n    warnings.simplefilter(\\\"ignore\\\")\\n    x = x.convert_objects(convert_numeric = True)\\nx = x.interpolate()\\nx.isnull().any().any() ## to check if any missing data\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nOr imputating missing values with the interpolate function from pandas.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ngbr = GradientBoostingRegressor(loss='ls', learning_rate=0.1, n_estimators=900,\\n                                subsample=1.0, min_samples_split=2, min_samples_leaf=1, max_depth=4, init=None,\\n                                random_state=None, max_features=None, alpha=0.5,\\n                                verbose=0, max_leaf_nodes=None, warm_start=False)\\n\\n%%time\\ngbr = gbr.fit(X_train,y_train)\\n#os.system('say \\\"終わりだ\\\"') #its over!\\n\\n#parameters = {'max_depth':range(2,5,1),'alpha':[0.5,0.6,0.7,0.8,0.9]}\\n#parameters = {'subsample':[0.2,0.4,0.5,0.6,0.8,1]}\\n#parameters = {'subsample':[0.2,0.5,0.6,0.8,1],'n_estimators':[800,1000,1200]}\\n#parameters = {'max_depth':range(2,4,1)}\\nparameters = {'n_estimators':[400,800,1100]}\\n#parameters = {'loss':['ls', 'lad', 'huber', 'quantile'],'alpha':[0.3,0.5,0.8,0.9]}\\n#parameters = {'learning_rate':[0.1,0.5,0.9]}\\n\\n\\n\\ngrid_gbr = grid_search.GridSearchCV(gbr, parameters,n_jobs=2,scoring=manualScorer)\\n\\n%%time\\ngrid_gbr = grid_gbr.fit(X_train,y_train)\\n\\nprint(grid_gbr.grid_scores_)\\nprint(\\\"Best: \\\",grid_gbr.best_params_)\\n\\nprint(gbr.score(X_train,y_train))\\nprint(gbr.score(X_test,y_test))\",\"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;\\n\",\"targets\":\"df.count()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2.3- Line Profiling: line_profiler\\nPython's native cProfile module and the corresponding %prun magic break down the execution time of code function by function. Sometimes, we may need an even more fine- grained analysis of code performance with a line-by-line report.\\nTo profile code line-by-line, we need an external Python module named line_profiler. To install it run one of these:\\n* conda install line_profiler\\n* pip install line_profiler\\nOnce installed import the line_profiler IPython extension module that comes with the package:\\n\",\"targets\":\"%load_ext line_profiler\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2. Import the independent time series\\nTwo explanatory series are used: the precipitation and the potential evaporation. These need to be pandas Series objects, as for the observed heads.\\nImportant characteristics of these time series are:\\n- All series are stored as pandas Series objects.\\n- The series may have irregular time intervals, but then it will be converted to regular time intervals when creating the time series model later on.\\n- It is preferred to use the same length units as for the observed heads.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Import observed precipitation series\\nprecip = pd.read_csv('..\\/data\\/rain_nb1.csv', parse_dates=['date'],\\n                     index_col='date', squeeze=True)\\nprint('The data type of the precip series is: %s' % type(precip))\\n\\n# Import observed evaporation series\\nevap = pd.read_csv('..\\/data\\/evap_nb1.csv', parse_dates=['date'],\\n                   index_col='date', squeeze=True)\\nprint('The data type of the evap series is: %s' % type(evap))\\n\\n# Calculate the recharge to the groundwater\\nrecharge = precip - evap\\nprint('The data type of the recharge series is: %s' % type(recharge))\\n\\n# Plot the time series of the precipitation and evaporation\\nplt.figure()\\nrecharge.plot(label='Recharge', figsize=(10, 4))\\nplt.xlabel('Time [years]')\\nplt.ylabel('Recharge (m\\/year)');\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Custom Aggregation\\nAn aggregation function collects many pieces of individual data and summarizes it in some way. Examples of built-in aggregation functions are avg() (average), min(), max(), and count().\\nThe API for aggregators used by sqlite3 is defined in terms of a class with two methods. The step() method is called once for each data value as the query is processed. The finalize() method is called one time at the end of the query and should return the aggregate value. This example implements an aggregator for the arithmetic mode. It returns the value that appears most frequently in the input.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport sqlite3\\nimport collections\\n\\ndb_filename = 'todo.db'\\n\\n\\nclass Mode:\\n\\n    def __init__(self):\\n        self.counter = collections.Counter()\\n\\n    def step(self, value):\\n        print('step({!r})'.format(value))\\n        self.counter[value] += 1\\n\\n    def finalize(self):\\n        result, count = self.counter.most_common(1)[0]\\n        print('finalize() -> {!r} ({} times)'.format(\\n            result, count))\\n        return result\\n\\n\\nwith sqlite3.connect(db_filename) as conn:\\n    conn.create_aggregate('mode', 1, Mode)\\n\\n    cursor = conn.cursor()\\n    cursor.execute(\\\"\\\"\\\"\\n    select mode(deadline) from task where project = 'pymotw'\\n    \\\"\\\"\\\")\\n    row = cursor.fetchone()\\n    print('mode(deadline) is:', row[0])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create a variable\\nTo create a variable, provide an initial value.  The tf.Variable will have the same dtype as the initialization value.\\n\",\"targets\":\"my_tensor = tf.constant([[1.0, 2.0], [3.0, 4.0]])\\nmy_variable = tf.Variable(my_tensor)\\n\\n# Variables can be all kinds of types, just like tensors\\nbool_variable = tf.Variable([False, False, False, True])\\ncomplex_variable = tf.Variable([5 + 4j, 6 + 1j])\",\"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\\/fcFinder Demo-checkpoint.ipynb\\\".\\nThe first task is:\\nCatching anatomical modifiers and creating annotations out of them\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmarkup2 = context.getSectionMarkups()[0]\\nmarkup2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create and fit Spark ML model\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom pyspark.ml.classification import LogisticRegression\\nfrom pyspark.ml.feature import VectorAssembler\\nfrom pyspark.ml import Pipeline\\n\\n# Create feature vectors. Ignore arr_delay and it's derivate, is_late\\nfeature_assembler = VectorAssembler(\\n    inputCols=[x for x in training.columns if x not in [\\\"is_late\\\",\\\"arrdelay\\\"]],\\n    outputCol=\\\"features\\\")\\n\\nreg = LogisticRegression().setParams(\\n    maxIter = 100,\\n    labelCol=\\\"is_late\\\",\\n    predictionCol=\\\"prediction\\\")\\n\\nmodel = Pipeline(stages=[feature_assembler, reg]).fit(training)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Import everything needed to edit\\/save\\/watch video clips\\nfrom moviepy.editor import VideoFileClip\\nfrom IPython.display import HTML\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTest on Videos\\nYou know what's cooler than drawing lanes over images? Drawing lanes over video!\\nWe can test our solution on two provided videos:\\nsolidWhiteRight.mp4\\nsolidYellowLeft.mp4\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Much larger than 800,000 nodes + edges. Does not need to render in 20 seconds. \\nurl = 'http:\\/\\/' + SERVER + '\\/graph\\/graph.html?dataset=Amazon&scene=default&info=true&play=10000&mapper=splunk&splashAfter=1477695505'\\nIFrame(url, width=700, height=350)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAmazon 262111 nodes , 1,234,877 Edges\\n\\nNodes - Products or Customers\\nEdges - A customer review\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create the figure\\nfig = figure(figsize=(10,4))\\nax = fig.add_subplot(121)\\nax.set_title('Decision boundary')\\n\\n# Chose the x-axis coords of the\\n# two points to plot the decision \\n# boundary line\\nx1 = array([lower_bound[0],upper_bound[0]])\\n\\n# Calculate the y-axis coords of the\\n# two points to plot the decision \\n# boundary line as it changes \\nfor t in xrange(stime) :\\n    \\n    # Show evert 10th timestep\\n    if t%10 == 0:\\n        \\n        if dw[2,t] != 0 :\\n            # Evaluate x2 based on current weights\\n            x2 = -(dw[1,t]*x1 + dw[0,t])\\/dw[2,t]\\n        \\n            # Plot the changes in the boundary line during learning\\n            ax.plot(x1,x2, c='#cccccc', linewidth = 1, zorder = 1)\\n\\n# Evaluate x2 ibased on final weights\\nx2 = -(w[1]*x1 + w[0])\\/w[2]\\n\\n# Plot the learned boundary line\\nplot(x1,x2, c= '#000000', linewidth = 2, zorder = 1)\\n\\n# Plot in red points belonging to the class\\nscatter(*P[(n_patterns\\/2):,:].T, s = 50,  c = '#ff8888', zorder = 2 )       \\n# Plot in blue points not belonging to the class \\nscatter(*P[:(n_patterns\\/2),:].T, s = 50,  c = '#8888ff', zorder = 2 )\\n\\n# Limits and labels of the plot\\nxlim( [lower_bound[0], upper_bound[0]] )\\nylim( [lower_bound[1], upper_bound[1]] )\\nxlabel(\\\"$p_1$\\\", size = 'xx-large')\\nylabel(\\\"$p_2$\\\", size = 'xx-large')\\n\\n# Plot squared errors\\nax = fig.add_subplot(122)\\nax.set_title('Error')\\nax.plot(squared_errors)\\n\\n# Labels and ticks of the plot\\nxlabel(\\\"epochs\\\", size = 'xx-large')\\nylabel(\\\"SSE\\\", size = 'xx-large')\\nxticks(range(epochs)) \\n\\nshow()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPlotting the results of training\\nWe plot the final decision boundary together with the history of the squared errors through epocs.\\nAs you see below, the network finds a line that completely divides points belonging to the class from those not belonging to it. The perceptron can only define a linear boundary, thus it cannot find any correct solution. The background of the \\\"Decision boundary\\\" plot is all gray. This was due to the fact that the network is continously exploring all the possible inclinations of the boundary. You can see in the error plot how the curve of the error do not converge to zero. The network cannot find a minimum in this case.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2 deque\\nDeques are a generalization of stacks and queues,Deques support thread-safe, memory efficient appends and pops from either side of the deque with approximately the same O(1) performance in either direction.\\n\\n\\nappend(x)\\nAdd x to the right side of the deque.\\n\\n\\nappendleft(x)\\nAdd x to the left side of the deque.\\n\\n\\nclear()\\nRemove all elements from the deque leaving it with length 0.\\n\\n\\ncount(x)\\nCount the number of deque elements equal to x.\\n\\n\\nextend(iterable) \\nExtend the right side of the deque by appending elements from the iterable argument.\\n\\n\\nextendleft(iterable)\\nExtend the left side of the deque by appending elements from iterable. Note, the series of left appends results in reversing the order of elements in the iterable argument.\\n\\n\\npop()\\nRemove and return an element from the right side of the deque. If no elements are present, raises an IndexError.\\n\\n\\npopleft()\\nRemove and return an element from the left side of the deque. If no elements are present, raises an IndexError.\\n\\n\\nremove(value)\\nRemoved the first occurrence of value. If not found, raises a ValueError.\\n\\n\\nreverse()\\nReverse the elements of the deque in-place and then return None.\\n\\n\\nrotate(n)\\nRotate the deque n steps to the right. If n is negative, rotate to the left. Rotating one step to the right is equivalent to: d.appendleft(d.pop()).\\n\\n\\nmaxlen\\nMaximum size of a deque or None if unbounded.\\n\\n\\n3 defaultdict\\ndictionary supply missing values\\n\",\"targets\":\"s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]\\nd = defaultdict(list)\\nfor k, v in s:\\n    d[k].append(v)\\nd.items()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Note the nature of the resulting index:\\ngiss_temp_series.index\\n\\n# It is an index made of 2 columns. Let's fix the fact that one of them doesn't have a name:\\ngiss_temp_series.index = giss_temp_series.index.set_names([\\\"year\\\", \\\"month\\\"])\\n\\n# We can now access deviations by specifying the year and month:\\ngiss_temp_series[1980, \\\"Jan\\\"]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nA side note: Multi-indexes\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Labs\\/Lab6\\/Lab6.ipynb\\\".\\nThe first task is:\\nSo tuples are immutable, but not indestructible. Once we've defined a new one, we can assign it to x and overwrite the original if we really want to\\nCan you write Python code for it?\\n\",\"targets\":\"\\nx=y\\nx\",\"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-Numpy.ipynb\\\".\\nThe first task is:\\nLos índices negativos se cuentan desde el fin del arreglo (los índices positivos desde el comienzo):\\nCan you write Python code for it?\\n\",\"targets\":\"\\nA = np.array([1,2,3,4,5])\\n\\nA[-1] # el último elemento del arreglo\\n\\nA[-3:] # los últimos 3 elementos\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"After using the show_topics method from the model, it will output the most probable words that appear in each topic. For the gensim library, the default printing behavior is to print a linear combination of the top words sorted in decreasing order of the probability of the word appearing in that topic. Thus words that appear towards the left are the ones that are more indicative of the topic.\\nWe see our LDA model has given us a pretty intuitive result. Bank is the most influential word in both the topics and other words help define what kind of bank we are talking about. We can also use the function get_term_topics and get_document_topics to further evaluate our result. get_term_topics returns the odds of that particular word belonging to a particular topic. A few examples:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint(texts_model.get_term_topics('water'))\\nprint(texts_model.get_term_topics('bank'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2. Save frame and display JPG here\\n\",\"targets\":\"frame = hdmi.frame()\\norig_img_path = '\\/home\\/xilinx\\/jupyter_notebooks\\/examples\\/data\\/orig.jpg'\\nframe.save_as_jpeg(orig_img_path)\\n\\nImage(filename=orig_img_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 \\\"Exploration_of_data_in_MillionMusicSubset.ipynb\\\".\\nThe first task is:\\nScatter plots of artist_familiarity vs year compared to artist_hotttnesss vs year\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfig, ax = plt.subplots(nrows=2, ncols=2, sharex=True, sharey=True,\\n                       figsize=(15,12))\\n\\nax[0,0].scatter(songs.year, songs.artist_familiarity, marker='.')\\nax[0,1].hexbin(songs.year, songs.artist_familiarity, cmap='viridis', gridsize=41, mincnt=1.0)\\n\\nax[1,0].scatter(songs.year, songs.artist_hotttnesss, marker='.')\\nax[1,1].hexbin(songs.year, songs.artist_hotttnesss, cmap='viridis', gridsize=41, mincnt=1.0)\\nax[-1,-1].set_xlim(1920,songs.year.max());\\nplt.subplots_adjust(wspace=0.02, hspace=0.05)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"P4B - Capitolo 2 - Persistenza, Unicode, OOP e DB.ipynb\\\".\\nThe first task is:\\nReferences python 2.7\\n\\nIL Tutorial\\nCoding Style\\n\\n\\nLe funzioni builtins (su ipython >>> help(__builtins__))\\nGli HowTo (tra cui \\\"Unicode HowTo\\\" e \\\"Idioms and Anti-Idioms in Python\\\")\\nThe absolute minimum every developer must know about unicode and character sets no excuses!\\nPragmatic Unicode\\nTipi, operatori e comparazioni\\nString format mini-language\\nDB-API 2.0 (PEP 249)\\nScope delle variabili (blog)\\nTest con PyTest\\n\\nFeedback sono graditi\\n\\nprivati via luca@befair.it , cell: 3289639660\\nvia telegram (sempre con il numero di cell)\\nse volete farli pubblici su www.befair.it\\nCan you write Python code for it?\\n\",\"targets\":\"\\nphrase = \\\"happy-python-hacking!\\\"\\nthe_end = u\\\" \\\".join([s.capitalize() for s in phrase.split(\\\"-\\\")])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"A function that has default arguments\\nPython allows you to have functions that have a default value for one or more arguments.  This allows you to call a function with fewer arguments than it is defined to allow (i.e., fewer than the maximum number of possible arguments).  In function definitions of this sort, the mandatory arguments (ones that do not have a default value) must come before the optional arguments (ones that have default values). This can be extremely helpful in many circumstances, and can be called in several ways:\\n\\nGiving only the mandatory argument\\nGiving the mandatory argument plus one of the optional arguments\\nGiving the mandatory argument plus two or more of the optional arguments\\n\\nThere does not need to be a mandatory argument - all arguments can have defaults!  Note that if you are going to give more than just the mandatory argument, the optional arguments need to be given in the order they are defined.  In other words, you can't just give the mandatory argument and the second optional argument in a function with one mandatory argument and multiple optional arguments - you have to give all arguments up to the one that you want.\\n\",\"targets\":\"# this version has one default value\\n\\ndef print_stuff(first,second='dog',third='monkey'):\\n    print(first,second,third)\\n\\nprint_stuff('cat')\\n\\nprint_stuff('cat','elephant')\\n\\nprint_stuff('donkey','wolf','mouse')\\n\\n# this version has no default values!\\n\\ndef print_stuff_2(first='fish',second='bird',third='dinosaur'):\\n    print(first,second,third)\\n\\nprint_stuff_2()\\n\\nprint_stuff_2('newt')\\n\\nprint_stuff_2('vole','koala')\\n\\nprint_stuff_2('lion','armadillo','cow')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"13.4. Redistribution\\nIs Required: TRUE&nbsp;&nbsp;&nbsp;&nbsp;Type: ENUM&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 1.N\\nWhich processes can redistribute sea ice (including thickness)?\\n\",\"targets\":\"# PROPERTY ID - DO NOT EDIT !  \\nDOC.set_id('cmip6.seaice.dynamics.redistribution')  \\n\\n# PROPERTY VALUE(S): \\n# Set as follows: DOC.set_value(\\\"value\\\")  \\n# Valid Choices: \\n#      \\\"Rafting\\\"  \\n#      \\\"Ridging\\\"  \\n#      \\\"Other: [Please specify]\\\"  \\nDOC.set_value(\\\"Ridging\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Can iterate this over a number of generations.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ngenerations = 500\\n\\ndef simulate():\\n    for i in range(generations):\\n        time_step()\\n\\nsimulate()\\n\\npop\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"CLeastAngleRegression requires the features to be normalized with a zero mean and unit norm. Hence we use two preprocessors: PruneVarSubMean and NormOne.\\n\",\"targets\":\"#Preprocess data\\npreproc=PruneVarSubMean()\\npreproc.init(feats_train)\\nfeats_train.add_preprocessor(preproc)\\nfeats_train.apply_preprocessor()\\n\\npreprocessor=NormOne()\\npreprocessor.init(feats_train)\\nfeats_train.add_preprocessor(preprocessor)\\nfeats_train.apply_preprocessor()\\n\\nprint \\\"(No. of attributes, No. of samples) of data:\\\"\\nprint feats_train.get_feature_matrix().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 \\\"Model Evaluation\\/Model_Evaluation-exercise.ipynb\\\".\\nThe first task is:\\n2 - Fit a machine learning algorithm of your choice to the data, tuning hyperparameters using the Better Holdout Method.  Generate training and validation plots and comment on your results.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# in solution he encodes all variables once using df.apply(le.fit_transform)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"But what does this UnicodeEncodeError mean?\\nUnicodeEncodeError: 'ascii' codec can't encode character u'\\\\xf7' in position 7984: ordinal not in range(128)\\n\\nWell, to find out, we need to dig a bit deeper and check the corresponding MATLAB script. Because every SPM interface creates an executable MATLAB script, either in the current location or in the folder of the node. So what's written in this script?\\n\",\"targets\":\"!cat \\/home\\/jovyan\\/work\\/notebooks\\/pyscript_realign.m\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# initial wf: gaussian(x,n,x0,s0,w,v) \\n# Gaussian centered at x0=0, width=w=1, velocity=v= 0, without nodes (s0=0)\\nc0=normaliza(gaussian(zp,Npoint,0,0,1,0)); # wf at t=0\\n#\\n# initial wf: thomas_fermi(x,n,x0,s0,gN,Ve) \\n# Thomas Fermi for harmonic oscillator without nodes (s0=0)\\n#c0=normaliza(thomas_fermi(zp,Npoint,0,0,gint\\/NormWF,Vpot_R)); # wf at t=0\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nChoose initial state (wave function)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create Pipeline\\n\",\"targets\":\"# Create standardizer\\nstandardizer = StandardScaler()\\n\\n# Create logistic regression\\nlogit = LogisticRegression()\\n\\n# Create a pipeline that standardizes, then runs logistic regression\\npipeline = make_pipeline(standardizer, logit)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As Figure 2 shows, the ordinal regresion model has once again calculated reasonable slope and intercept coefficients such that the model's decision boundaries align with our intuition of the underlying data distribution.\\nApplied example for housing quantiles\\nWhile it is difficult to visualize the decision boundaries for datasets with $p>2$, an examination of the coefficients and performance of a model can indicate whether it is working well. To compare how ordinal regression fares to more common methods, housing prices from the Boston housing dataset will be converted in different quantiles (bottom 10-20%, top 90+%, etc). The ordinal approach will be compared to a simple linear regression model where each quantile is treated as an integer ($y=[1,2,\\\\dots,10]$) and a multinomial logistic regression where each class is treated as independently. To assess performance, the mean-absolute error (MAE) between the predicted and actual class will be used. For ordinal regression tasks, a metric like raw accuracy is less appealing as predicting 1 or 10 when $y=2$ receives the same score, when clearly predicting a quantile closer to the ground-truth level is more \\\"accurate\\\" even if it is not perfect. In the simulations below, a training\\/test split of 80\\/20% is used and run 125 times. Note that the house price label has added noise to it to ensure that quantiles can be calculated more smoothly.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.datasets import load_boston\\nfrom sklearn.model_selection import train_test_split\\nfrom sklearn.linear_model import LinearRegression\\nfrom sklearn.linear_model import LogisticRegression\\n\\nX, y = load_boston(True)\\ny = np.log(y)\\nnp.random.seed(1234)\\ny = y + np.random.randn(len(y))*(0.2*y.std())\\n\\nnq = 10\\nthresholds = np.append(np.append(y.min()-1,np.quantile(y,np.arange(0,1,1\\/nq)[1:])),y.max()+1)\\nyq = pd.cut(x=y,bins=thresholds,right=True,labels=['q'+str(z+1) for z in range(nq)])\\nyord = yq.astype('category').codes+1\\n\\nnp.seterr(divide='ignore', invalid='ignore')\\nholder = []\\nnsim = 125\\nfor ii in range(nsim):\\n  # Do a train\\/test split (80\\/20)\\n  ytrain, ytest, Xtrain, Xtest = train_test_split(yord, X, stratify=yord,test_size=0.2,random_state=ii)\\n  # Ordinal regression model\\n  mdl_ord = ordinal_reg()\\n  mdl_ord.fit(Xtrain, ytrain)\\n  # Linear regression\\n  mdl_linreg = LinearRegression().fit(Xtrain, ytrain)\\n  # Multinomial regression\\n  mdl_multi = LogisticRegression(penalty='none',solver='lbfgs',max_iter=1000)\\n  mdl_multi.fit(mdl_ord.Xenc.transform(Xtrain),ytrain)\\n  # Make predictions\\n  yhat_linreg = np.round(mdl_linreg.predict(Xtest)).astype(int)\\n  yhat_multi = mdl_multi.predict(mdl_ord.Xenc.transform(Xtest))\\n  yhat_ord = mdl_ord.predict(data=pd.DataFrame(Xtest))\\n  # Get accuracy\\n  acc_linreg = np.abs(yhat_linreg - ytest).mean()\\n  acc_multi = np.abs(yhat_multi == ytest).mean()\\n  acc_ord = np.abs(yhat_ord == ytest).mean()\\n  holder.append(pd.DataFrame({'ord':acc_ord,'multi':acc_multi,'linreg':acc_linreg},index=[ii]))\\n\\ndf_mae = pd.concat(holder).mean(axis=0).reset_index().rename(columns={'index':'mdl',0:'MAE'})\\ndi_lbls = {'ord':'Ordinal','multi':'Multinomial','linreg':'Linear Regression'}\\ndf_mae = df_mae.assign(mdl=lambda x: x.mdl.map(di_lbls))\\nprint(np.round(df_mae,1))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"A new high performance and optimally cheap multivitamin. Saving the world one mixed integer program at a time\\nYou have been tasked with developing a new superior multivitamin. You have been given free reign to select the ingredients and their relative amounts in the vitamin but you have been asked to keep the cost of the raw materials as low as possible.\\nFurther complicating things, you must abide by some restrictions in the formula.\\n\\nThe formula should not have more than 20% of any one vitamin\\nThe formula must have at least 10% Iron, Zinc, or Magnesium\\nThe formula must have at least 20% Vitamin A, Vitamin C, or Vitamin D\\nEach vitamin that is used must account for at least 5% of the total\\nThe formula may contain as few as 5 vitamins but no more than 10 vitamins\\nIf the formula contains Magnesium it must also contain Calcium and Zinc\\nThe formula must have one of the B vitamins either B6 or B12 but not both\\n\\nThe possible Ingredients and their per mg cost\\n{{HTML(df.to_html(index=False)) }}\\nYou might see a simple greedy strategy to solve this, but the vitamin B constrains and the Magnesium\\/Zinc\\/Calcium constraints make things a bit more complicated. Instead of trial and error we can try and create this vitamin by writing a fairly simple mixed integer linear program. First we need to come up with an expression that captures our ultimate goal, in this case, to minimize the cost of raw materials.\\nWe can calculate the total cost of the formula by adding up the individual cost of each vitamin in it.\\n$$\\\\text{Total Cost} = \\\\text{ sum over all the vitamins (cost of vitamin) * (percent of vitamin) } $$\\nFirst lets load the data we have and organize it so we can easily grab the cost of particular vitamin\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndf = pd.read_csv('vitamin_costs.csv')\\nvitamins = df.vitamin.values\\nvitamin_cost = df.set_index('vitamin').to_dict()['cost']\\ndf.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Convolutional Neural Network (CNN)\\nTODO 3: Update the CNN architecture\\nTry adjusting the # of filters (pattern types) and kernel size (size of the sliding window)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom tensorflow.keras.layers import AveragePooling1D\\n\\n# TODO: Try adjusting the # of filters (pattern types) and kernel size (size of the sliding window)\\nmodel = Sequential([\\n    Conv1D(filters=32, kernel_size=3, input_shape=[n_input_steps, n_features]),\\n    Flatten(),\\n    Dense(n_output_steps)])\\n\\nmodel.compile(optimizer='adam', loss='mae')\\n\\nearly_stopping = EarlyStopping(monitor='val_loss', patience=5)\\n_ = model.fit(x=X_train, y=y_train, validation_data=(X_test, y_test), epochs=epochs, callbacks=[early_stopping])\\n\\nmodel.save('.\\/cnn_export\\/')\\n\\npreds = model.predict(X_test)\\ny_pred_cnn = inverse_scale(preds)\\n\\nevaluate(y_pred_cnn)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Set up the model\\nvalueDate = Date(2016, 9, 17)\\nmaximumDate = Date(2026, 9, 17)\\n\\ndates = [Date(2016, 9, 17) , Date(2026, 9, 17)]\\nrates = [ 0.07, 0.07 ]\\ndiscountCurve = DatesAndRates(Currency.ZAR, valueDate, dates, rates, maximumDate)\\n\\nnumeraireModel = DeterminsiticCurves(discountCurve);\\notherModels = List[Simulator]() # no model other than discounting for now.\\ncoordinator = Coordinator(numeraireModel, otherModels, 1) # the magic ingredient that gets \\n                                                          # models and products to work \\n                                                          # together\\n\\nprint(\\\"A model is ready.\\\")\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSetting up a model\\nWe haven't described how to make a model or exactly what it does but the following code is fairly easy to understand:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Check the 2016 customers\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\na = known_behaviors[known_behaviors.Mortgage == 1]\\nb = known_behaviors[known_behaviors.Pension == 1]\\nc = known_behaviors[known_behaviors.Savings == 1]\\nprint(\\\"Number of clients: %d\\\" %len(known_behaviors))\\nprint(\\\"Number of clients predicted to buy mortgage accounts: %d\\\" %len(a))\\nprint(\\\"Number of clients predicted to buy pension accounts: %d\\\" %len(b))\\nprint(\\\"Number of clients predicted to buy savings accounts: %d\\\" %len(c))\\n\\nknown_behaviors[\\\"nb_products\\\"] = known_behaviors.Mortgage + known_behaviors.Pension + known_behaviors.Savings\\n\\nabc = known_behaviors[known_behaviors.nb_products > 1]\\nprint(\\\"We have %d clients who bought several products\\\" %len(abc))\\nabc = known_behaviors[known_behaviors.nb_products == 3]\\nprint(\\\"We have %d clients who bought all the products\\\" %len(abc))\\n\\nproducts = [\\\"Savings\\\", \\\"Mortgage\\\", \\\"Pension\\\"]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Convert training data to TFRecord\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%cd models\\/research\\/slim\\n\\n! .\\/prepare_checkpoint_and_dataset.sh --network_type mobilenet_v1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%bq query\\nselect\\nproductorservicecode,\\nsystemequipmentcode,\\nclaimantprogramcode,\\nprincipalnaicscode,\\nsum(dollarsobligated) as dollarsobligated\\nfrom `fiery-set-171213.vrec.usa_spending_all`\\nwhere vendorname in ('LOCKHEED MARTIN CORPORATION')\\ngroup by 1,2,3,4\\norder by 5 DESC\\nlimit 20\\n\\n%%bq query\\nselect\\n#mod_parent,\\nvendorname,\\nsystemequipmentcode,\\nsum(dollarsobligated) as dollarsobligated\\nfrom `fiery-set-171213.vrec.usa_spending_all`\\nwhere productorservicecode in ('1510: AIRCRAFT, FIXED WING')\\ngroup by 1,2\\norder by 3 DESC\\nlimit 20\\n\\n%%bq query\\nselect\\nvendorname,\\nsystemequipmentcode,\\nclaimantprogramcode,\\nprincipalnaicscode,\\nsum(dollarsobligated) as dollarsobligated\\nfrom `fiery-set-171213.vrec.usa_spending_all`\\nwhere productorservicecode in ('1510: AIRCRAFT, FIXED WING')\\nand contractingofficerbusinesssizedetermination in ('S: SMALL BUSINESS')\\ngroup by 1,2,3,4\\norder by dollarsobligated DESC\\nlimit 20\\n\\n%%bq query\\nselect\\n*\\nfrom `gpqueries.contracts.raw`\\nwhere productorservicecode in ('1510: AIRCRAFT, FIXED WING')\\nand contractingofficerbusinesssizedetermination in ('S: SMALL BUSINESS')\\nlimit 1\\n\\n%%bq query\\nselect \\nclaimantprogramcode,\\nprincipalnaicscode,\\nsum(dollarsobligated) as dollarsobligated\\nfrom `fiery-set-171213.vrec.usa_spending_all`\\nwhere contractingofficerbusinesssizedetermination in (\\\"S: SMALL BUSINESS\\\")\\ngroup by 1,2\\norder by dollarsobligated DESC\\nlimit 10\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUnderstanding where the budget is spent\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Miscellaneous\\/Adult Income Classification.ipynb\\\".\\nThe first task is:\\nKNN accuracy and time elapsed caculation\\nCan you write Python code for it?\\n\",\"targets\":\"\\nt6=time()\\nprint (\\\"KNN\\\")\\n# knn = KNeighborsClassifier(n_neighbors=3)\\nknn = KNeighborsClassifier()\\nclf_knn=knn.fit(X_train, y_train)\\nprint (\\\"Acurracy: \\\", clf_knn.score(X_test,y_test) )\\nt7=time()\\nprint (\\\"time elapsed: \\\", t7-t6)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"But what if we want to change the formatting?\\n\",\"targets\":\"#ax stands for \\\"axis\\\", we'll use this object to change more settings\\n#we can also specify the image size, in inches, right here with the figsize argument\\nax = tmp.plot.line(y='log_salary', figsize=(10,8))\\n\\n#add a title to the chart\\nax.set_title('Average salary by year born')\\n\\n#label the axes\\nax.set_ylabel('log(salary)')\\nax.set_xlabel('Year born')\\n\\n#set the ticks so they're not half years\\n#The range command makes a list of years starting in 1972 and counting by 2 up to (not including) 1993.\\nax.set_xticks(range(1972, 1993, 2))\\n\\n#show our plot\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Adding depth and sparsity constraint on the encoded representations\\nIn the previous example, the representations were only constrained by the size of the hidden layer (32). In such a situation, what typically happens is that the hidden layer is learning an approximation of PCA (principal component analysis). But another way to constrain the representations to be compact is to add a sparsity contraint on the activity of the hidden representations, so fewer units would \\\"fire\\\" at a given time. \\nIn Keras, this can be done by adding an activity_regularizer to our Dense layer:\\n\",\"targets\":\"#autoencoder.reset_states()\\n#encoder.reset_states()\\n#decoder.reset_states()\\n\\nfrom keras import regularizers\\nfrom keras import optimizers\\nfrom keras.regularizers import l2, activity_l1\\nfrom keras.layers import Input, Dense\\nfrom keras.models import Model\\n\\ninput_img = Input(shape=(784,))\\nencoded = Dense(128, activation='relu')(input_img)\\nencoded = Dense(64, activation='relu')(encoded)\\nencoded = Dense(32, activation='relu')(encoded)\\ndecoded = Dense(64, activation='relu')(encoded)\\ndecoded = Dense(128, activation='relu')(decoded)\\ndecoded = Dense(784, activation='sigmoid')(decoded)\\n\\nautoencoder = Model(input_img, decoded)\\nautoencoder.compile(optimizer='adadelta', \\n                    loss='binary_crossentropy',\\n                    activity_regularizer=regularizers.l1(10e-5))\\n\\nautoencoder.fit(x_train, x_train,\\n                nb_epoch=100,\\n                batch_size=256,\\n                shuffle=True,\\n                validation_data=(x_test, x_test))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"4_dlnd_language_translation\\/dlnd_language_translation.ipynb\\\".\\nThe first task is:\\nProcess Decoding Input\\nImplement process_decoding_input using TensorFlow to remove the last word id from each batch in target_data and concat the GO ID to the begining of each batch.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef process_decoding_input(target_data, target_vocab_to_int, batch_size):\\n    \\\"\\\"\\\"\\n    Preprocess target data for dencoding\\n    :param target_data: Target Placehoder\\n    :param target_vocab_to_int: Dictionary to go from the target words to an id\\n    :param batch_size: Batch Size\\n    :return: Preprocessed target data\\n    \\\"\\\"\\\"\\n    \\n    go_id = target_vocab_to_int.get('<GO>')\\n    gos = tf.fill(dims=(batch_size,1), value=go_id)\\n    return tf.concat((gos, target_data[:,:-1]), axis=1)\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_process_decoding_input(process_decoding_input)\",\"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_notebooks\\/Notebook_4_Generating_Model_Directed_Evolution_of_UTRs_From_100_Native_and_Random_UTRs.ipynb\\\".\\nThe first task is:\\nOrganize the data\\nreshape and combine the dataframes with the sequences and the predicted growth rates\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# reshape the dataframes. Transpose, then convert into a Multiindex, then convert the index into new columns\\nran_seqs_df = mut_random_seqs[0].T.unstack().reset_index()\\nran_scores_df = mut_random_seqs[1].T.unstack().reset_index()\\n\\n# rename the columns so that the names are somewhat descriptive\\nran_seqs_df.rename(columns = {'level_0' : 'UTR_id', 'level_1' : 'Round', 0 : 'Evolved_Seq'}, inplace = True)\\nran_scores_df.rename(columns = {'level_0' : 'UTR_id', 'level_1' : 'Round', 0 : 'Pred_Growth'}, inplace = True)\\n\\n# merge two datasets, only include columns that aren't redundant\\ncols_to_use = ran_scores_df.columns.difference(ran_seqs_df.columns) # identify non-redundant columns\\nran_seqs_scores = pd.merge(ran_seqs_df, ran_scores_df[cols_to_use], right_index = True, left_index = True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As you can see, these DataFrames are consistent with the format expected by solutionFactory.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nbuyDf\\n\\nconsumeDf\",\"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. Parte 2\\/13. Clase 13\\/13Class NB.ipynb\\\".\\nThe first task is:\\n2. Modelo normal para los rendimientos\\nCan you write Python code for it?\\n\",\"targets\":\"\\nhuber = sm.robust.scale.Huber()\\nreturns_av, scale = huber(daily_returns)\\nmu=daily_returns.mean().AAPL\\nsigma=daily_returns.std().AAPL\\nndays = 360\\nntraj=10000\\nK1=160\\nK2=180\\n\\nmu=daily_returns.mean().AAPL\\nsigma=daily_returns.std().AAPL\\ndates=pd.date_range('20170101',periods=ndays)\\nsimret = pd.DataFrame(sigma*np.random.randn(ndays,ntraj)+mu,index=dates)\\nsimdata=(data.loc['2016-12-30',:].AAPL)*np.exp(simret.cumsum())\\nST=simdata.tail(1)\\nind=np.digitize(ST.values[0],np.array([0, K1, K2, ST.values.max()+1]))\\nfreq=(np.array([sum(ind==1),sum(ind==2),sum(ind==3)])\\/ntraj)*100\\n\\nbar_labels = ['ST<K1', 'K1<ST<K2', 'ST>K2']\\nx_pos = list(range(len(bar_labels)))\\nplt.bar(x_pos,freq);\\nplt.grid();\\nplt.xticks(x_pos, bar_labels);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%bash\\nbq --location=US mk -d demo\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTrain Model\\nWith the relevant columns chosen to accomplish predictions, it is then possible to create and train the model in BigQuery. First, a dataset will be needed store 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 \\\"Python\\/5 Linear Regression\\/Polynomial-Regression.ipynb\\\".\\nThe first task is:\\nThis seems to be working and the explained variance has improved. Let's try to use even higher order polynomials.  Hopefully, we can get a $100\\\\%$ explained variance.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nplot_nth_degree_polynomial(6)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2 Categories\\nCategorical data is best represented by bar or pie charts. Reproduce the plots below using the object-oriented API of matplotlib, which is recommended for programming.\\nQuestion: What are the pros \\/ cons of each plot ?\\nTip: the matplotlib gallery is a convenient starting point.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndata = [10, 40, 25, 15, 10]\\ncategories = list('ABCDE')\\n\\nfig, axes = plt.subplots(1, 2, figsize=(15, 5))\\n\\n# Right plot.\\n# axes[1].\\n# axes[1].\\n\\n# Left plot.\\n# axes[0].\\n# axes[0].\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%csound 1\\ninstr 1\\nasig asds\\n\\n%%csound 1\\ninstr 1\\nasig oscil 0.5, 440\\nouts asig, asig\\n\\n%%csound 1\\ninstr 1\\nasig oscil 0.5, 440\\nouts asig, asig\\nendin\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSending instruments\\nYou can send instruments to a running csound engine with the %%csound magic. Any syntax errors will be displayed inline.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Load COCO data from disk; this returns a dictionary\\n# We'll work with dimensionality-reduced features for this notebook, but feel\\n# free to experiment with the original features by changing the flag below.\\ndata = load_coco_data(pca_features=True)\\n\\n# Print out all the keys and values from the data dictionary\\nfor k, v in data.iteritems():\\n  if type(v) == np.ndarray:\\n    print k, type(v), v.shape, v.dtype\\n  else:\\n    print k, type(v), len(v)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLoad MS-COCO data\\nAs in the previous notebook, we will use the Microsoft COCO dataset for captioning.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Backends\\nPyMC3 has support for different ways to store samples during and after sampling, called backends, including in-memory (default), text file, and SQLite. These can be found in pymc.backends:\\nBy default, an in-memory ndarray is used but if the samples would get too large to be held in memory we could use the sqlite backend:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom pymc3.backends import SQLite\\n\\nwith model_glm_logistic:\\n    backend = SQLite('trace.sqlite')\\n    trace = sample(5000, trace=backend)\\n\\nsummary(trace, vars=['x1', 'x2'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Compute the eccentricties\\ndef ecc(q, v, t):\\n    Q = np.vstack([q, np.zeros(t.size)])\\n    V = np.vstack([v, np.zeros(t.size)])\\n    qT, vT = np.transpose(Q), np.transpose(V)\\n    return np.array( [orbit.Calc_e(qT[ii], vT[ii], (1.-beta)*G*M_Sun) for ii in range(t.size)])\\n\\ne_slim2 = ecc(q_slim2, pi_slim2\\/m, t)\\ne_slim4 = ecc(q_slim4, pi_slim4\\/m, t)\\ne_slim6 = ecc(q_slim6, pi_slim6\\/m, t)\\ne_rk2 = ecc(q_rk2, v_rk2, t)\\ne_rk4 = ecc(q_rk4, v_rk4, t)\\n\\nfig3 = plt.figure(figsize=(12,5), dpi=500)\\nax3 = fig3.add_subplot(1,1,1)\\n\\nax3.set_xlim(0.01, 6000)\\nax3.loglog(t, np.abs(e_slim2\\/e_slim6-1.), 'r-', linewidth=2.0, rasterized=True)\\nax3.loglog(t, np.abs(e_slim4\\/e_slim6-1.), '-', color='orange', linewidth=2.0, rasterized=True)\\nax3.loglog(t, np.abs(e_rk2\\/e_slim6-1.), 'g--', linewidth=2.0, rasterized=True)\\nax3.loglog(t, np.abs(e_rk4\\/e_slim6-1.), 'b--', linewidth=2.0, rasterized=True)\\n\\nax3.set_xlabel('Time, $t$ [yr]', fontsize=18)\\nax3.set_ylabel('Frac\\\\'l Eccentricity Error, $\\\\delta e\\/e_6$', fontsize=18)\\n\\nax3.text(20, 1.8e-3, r'$2^{nd}$ order Slimplectic', fontsize=15, color='black')\\nax3.text(20, 0.5e-7, r'$4^{th}$ order Slimplectic', fontsize=15, color='black')\\nax3.text(40, 1e-4, r'$4^{th}$ order RK', fontsize=15, color='blue', rotation = 10)\\nax3.text(40, 1e0, r'$2^{nd}$ order RK', fontsize=15, color='g', rotation=10)\\n\\nax3.tick_params(axis='both', which='major', labelsize=16)\\nax3.set_yticks([1e-12, 1e-9, 1e-6, 1e-3, 1e0])\\nax3.text(0.015, 1e0, r'$\\\\Delta t = 0.01$ yr', fontsize=18, color='black'); \\n\\n#fig3.savefig(plot_path + \\\"PRDrag_Ecc_errorLong.pdf\\\", transparent=True,bbox_inches='tight')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe can also look at how the orbital eccentricity changes depending on the integration scheme and order.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Below, we will plot the rolling mean values that will be used to calculate 1993's number of bombings. We will use a lookback window of 4 years to smooth out any random spikes that occur over time, and get a more general line to capture these trends over the time period of interest.\\n\",\"targets\":\"## Pandas has rolling mean function\\npd.rolling_mean(bombing, 4)\\n\\n## Using the function created above to show this visually\\ntest_stationarity(bombing, 4)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# For 00, do nothing\\n\\n# For 01, apply $X$\\n#shared.x(q[0])\\n\\n# For 01, apply $Z$\\n#shared.z(q[0])\\n\\n# For 11, apply $XZ$\\nsuperdense.z(sdq[0]) \\nsuperdense.x(sdq[0])\\nsuperdense.barrier()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAlice now needs to decide what two bit message she wants to transmit to Bob, ($00$, $01$, $10$, or $11$), and perform the corresponding to transformation ($I$, $X$, $Z$ or $XZ$ respectively) to her qubit $q_A$ ($q_0$). In this case, she encodes $11$:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Define a saturation nonlinearity as a simple function\\ndef my_saturation(x):\\n    if abs(x) >= 1:\\n        return math.copysign(1, x)\\n    else:\\n        return x\\n\\namp_range = np.linspace(0, 2, 50)\\nplt.plot(amp_range, ct.describing_function(my_saturation, amp_range).real)\\nplt.xlabel(\\\"Amplitude A\\\")\\nplt.ylabel(\\\"Describing function, N(A)\\\")\\nplt.title(\\\"Describing function for a saturation nonlinearity\\\");\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUser-defined, static nonlinearities\\nIn addition to pre-defined nonlinearies, it is possible to computing describing functions for static nonlinearities.  The describing function for any suitable nonlinear function can be computed numerically using the describing_function function.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Calculate torque in N-m.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntau_ind = Pag \\/ w_sync\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Download the model from GCS\\ndownload_from_gcs(PRETRAINED_KERAS_MODEL, 'pretrained_model.h5')\\n\\n# Load the model, strategy.scope allows us to exploit multiple accelerators,\\n# just like we did during training.\\nwith strategy.scope():\\n  model = tf.keras.models.load_model('pretrained_model.h5', compile=False)\\n  model.compile(\\n      optimizer=tf.train.AdamOptimizer(), loss=weighted_binary_crossentropy)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThen we'll download and load the keras model.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Concise test<a name=\\\"_concise test\\\"><\\/a>\\n\",\"targets\":\"contingency_name_from_id = {\\n    0: 'Nível basal',\\n    1: 'Nível 0',\\n    2: 'Nível 1',\\n    3: 'Nível 2',    \\n}\\n\\ndef alert_trigger(dataset_id: int, year: int, territory_id: int):\\n    df = fluDB.get_data(dataset_id=dataset_id, scale_id=1, year=year, territory_id=territory_id)\\n\\n    # If not obitoflu dataset (3), uses last 4 weeks, o.w. use 3:\\n    if dataset_id < 3:\\n        wdw = 4\\n    else:\\n        wdw = 3\\n\\n    alert_zone = any(df.estimated_cases[-wdw:] > df.typical_high[-wdw:])\\n    data_increase = all(df.estimated_cases[-wdw:].values - df.estimated_cases[-(wdw+1):-1].values > 0)\\n\\n    return(alert_zone & data_increase)\\n\\n\\ndef contingency_level(year: int, territory_id: int):\\n    \\n    if alert_trigger(dataset_id=3, year=year, territory_id=territory_id):\\n        return(3)\\n    elif alert_trigger(dataset_id=2, year=year, territory_id=territory_id):\\n        return(2)\\n    elif alert_trigger(dataset_id=1, year=year, territory_id=territory_id):\\n        return(1)\\n    else:\\n        return(0)\\n\\ncontingency_name_from_id[contingency_level(year=year, territory_id=territory_id)]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Fill in your code here.\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLet's now try drawing the graph.\\nExercise\\nUse nx.draw(my_graph) to draw the filtered graph to screen.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#Xtest = np.vstack([ testdatacand['ug'], testdatacand['gr'], testdatacand['ri'], testdatacand['iz'], testdatacand['zs1'], testdatacand['s1s2']]).T\\nXtest = np.vstack([np.asarray(testdatacand[name]) for name in ['ug', 'gr', 'ri', 'iz', 'zs1', 's1s2']]).T\\n\\nXStest = scaler.transform(Xtest)  # apply same transformation to test data\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nScale the test data\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%load solutions\\/random_number.py\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise: Random numbers\\nGenerate a NumPy array of 1000 random numbers sampled from a Poisson distribution, with parameter lam=5. What is the modal value in the sample?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# dense input\\nYdense  = np.random.rand(10, 20)\\ntrainSession = smurff.TrainSession(burnin = 5, nsamples = 5)\\ntrainSession.addTrainAndTest(Ydense)\\ntrainSession.run()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nInput to SMURFF\\nIn this notebook we will look at how to provide input to SMURFF with dense and sparse matrices;\\nSMURFF accepts the following matrix files for train, test and side-info data:\\n\\nfor dense matrix or tensor input:\\n  numpy.ndarrays\\nfor sparse matrices input:\\n  scipy Sparse matrices in COO, CSR or CSC format\\nfor sparse tensors: a wrapper around a\\n  pandas.DataFrame\\n\\nLet's have a look on how this could work.\\nDense Train Input\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"4.2. Create Finite Element space (Lagrange P1)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nV = FunctionSpace(mesh, \\\"Lagrange\\\", 1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"!bq show --format=prettyjson -j fae46669-5e96-4744-9d2c-2b1b95fa21e7\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nBe sure to replace the job id with your own most recent job.\",\"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_basics_variables_ex2.ipynb\\\".\\nThe first task is:\\nVariable State\\nCan you write Python code for it?\\n\",\"targets\":\"\\n>>> session1 = tf.Session(graph=graph)\\n>>> session2 = tf.Session(graph=graph)\\n>>> x.initializer.run(session=session1)\\n>>> x.initializer.run(session=session2)\\n\\n>>> increment_op.eval(session=session1)\\n\\n>>> x.eval(session=session1)\\n\\n>>> x.eval(session=session2)\\n\\n>>> session1.close()\\n>>> session2.close()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"3rd q ring 0.00288861 (1\\/ Angstroms)\\n\",\"targets\":\"fig, axes = plt.subplots(figsize=(6, 6))\\naxes.set_xlabel(\\\"K\\/<K>\\\")\\naxes.set_ylabel(\\\"P(K)\\\")\\nfor i in range(3):\\n    art, = axes.plot(norm_bin_edges[i, 2][:-1], p_K[i, 2], '-o', label=str(time_steps_5[i])+\\\" ms\\\" )\\n    axes.set_xlim(0, 4)\\n    axes.legend()\\nplt.title(\\\"3rd q ring 0.00288861 (1\\/ Angstroms)\\\")\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Comment:\\nSuprisingly, the cap color is not the great predictor of etability of a mushroom. Different colors have varied distributions among both classes. Just a few species with red and yellow caps tend to be poisonous more often, while brown, gray and white caps are more prevailant among etable mushrooms. However, one cannot draw any definitive conclusion and we need to investgate more charactristics.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ngills = pd.crosstab(index=df['classif'], columns=df[\\\"gill_color\\\"])\\nprint(gills)\\n#gill-color: black=k,brown=n,buff=b,chocolate=h,gray=g,green=r,orange=o,pink=p,purple=u,red=e, white=w,yellow=y\\ns1 = pd.crosstab(index=df['classif'], columns = df['gill_size'])\\nprint(s1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"5.4. Plotting the confidence intervals\\nOn top of the previous figure (copy here your code from the previous section), plot functions\\n$${\\\\mathbb E}\\\\left{f({\\\\bf x}^\\\\ast)\\\\mid{\\\\bf s}\\\\right}$$\\nand\\n$${\\\\mathbb E}\\\\left{f({\\\\bf x}^\\\\ast)\\\\mid{\\\\bf s}\\\\right} \\\\pm 2 \\\\sqrt{{\\\\mathbb V}\\\\left{f({\\\\bf x}^\\\\ast)\\\\mid{\\\\bf s}\\\\right}}$$\\n(i.e., the posterior mean of $f({\\\\bf x}^\\\\ast)$, as well as two standard deviations above and below).\\nIt is possible to show analytically that this region comprises $95.45\\\\%$ probability of the posterior probability $p(f({\\\\bf x}^\\\\ast)\\\\mid {\\\\bf s})$ at each ${\\\\bf x}^\\\\ast$.\\n\",\"targets\":\"# Note that you can re-use code from sect. 4.2 to solve this exercise\\n\\n# Plot the training points \\n# plt.plot(X, Z.dot(true_w), 'b', label='True model', linewidth=2);\\nplt.plot(X0train, strain,'b.',markersize=2);\\nplt.xlim(xmin, xmax);\\n# <\\/SOL>    \\n\\n# Plot the posterior mean.\\n# mean_s = <FILL IN>\\nplt.plot(X, mean_s, 'g', label='Predictive mean', linewidth=2);\\n\\n# Plot the posterior mean +- two standard deviations\\n# std_f = <FILL IN>\\n\\n# Plot the confidence intervals.\\n# To do so, you can use the fill_between method\\nplt.fill_between(X.flatten(), (mean_s - 2*std_f).flatten(), (mean_s + 2*std_f).flatten(),\\n                 alpha=0.4, edgecolor='#1B2ACC', facecolor='#089FFF', linewidth=2)\\n\\n# plt.legend(loc='best')\\nplt.xlabel('$x$',fontsize=14);\\nplt.ylabel('$s$',fontsize=14);\\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 \\\"1. Learning from data and optimization.ipynb\\\".\\nThe first task is:\\nLearning from data\\nIn general, we have:\\n\\nA dataset ${(\\\\mathbf{x},y)}$ of $n$ examples. \\nA target function $f_\\\\mathbf{w}$, that we want to minimize, representing the discrepancy between our data and the model we want to fit. The model is represented by a set of parameters $\\\\mathbf{w}$. \\nThe gradient of the target function, $g_f$. \\n\\nIn the most common case $f$ represents the errors from a data representation model $M$. \\nFor example, to fit the model clould be to find the optimal parameters $\\\\mathbf{w}$ that minimize the following expression:\\n$$ f_\\\\mathbf{w} = \\\\frac{1}{n} \\\\sum_{i} (y_i - M(\\\\mathbf{x}_i,\\\\mathbf{w}))^2 $$\\nFor example, $(\\\\mathbf{x},y)$ can represent:\\n\\n$\\\\mathbf{x}$: the behavior of a \\\"Candy Crush\\\" player; $y$: monthly payments. \\n$\\\\mathbf{x}$: sensor data about your car engine; $y$: probability of engine error.\\n$\\\\mathbf{x}$: finantial data of a bank customer; $y$: customer rating.\\n\\n\\nIf $y$ is a real value, it is called a regression problem.\\nIf $y$ is binary\\/categorical, it is called a classification problem. \\n\\nLet's suppose that our model is a one-dimensional linear model $M(\\\\mathbf{x},\\\\mathbf{w}) = w \\\\cdot x $. \\nBatch gradient descend\\nWe can implement gradient descend in the following way (batch gradient descend):\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport numpy as np\\nimport random\\n\\n# f = 2x\\nx = np.arange(10)\\ny = np.array([2*i for i in x])\\n\\n# f_target = 1\\/n Sum (y - wx)**2\\ndef target_f(x,y,w):\\n    return np.sum((y - x * w)**2.0) \\/ x.size\\n\\n# gradient_f = 2\\/n Sum 2wx**2 - 2xy\\ndef gradient_f(x,y,w):\\n    return 2 * np.sum(2*w*(x**2) - 2*x*y) \\/ x.size\\n\\ndef step(w,grad,alpha):\\n    return w - alpha * grad\\n\\ndef BGD_multi_step(target_f, \\n                   gradient_f, \\n                   x, \\n                   y, \\n                   toler = 1e-6):\\n    \\n    alphas = [100, 10, 1, 0.1, 0.001, 0.00001]\\n    w = random.random()\\n    val = target_f(x,y,w)\\n    i = 0\\n    while True:\\n        i += 1\\n        gradient = gradient_f(x,y,w)\\n        next_ws = [step(w, gradient, alpha) for alpha in alphas]\\n        next_vals = [target_f(x,y,w) for w in next_ws]\\n        min_val = min(next_vals)\\n        next_w = next_ws[next_vals.index(min_val)]   \\n        next_val = target_f(x,y,next_w)    \\n        if (abs(val - next_val) < toler):\\n            return w\\n        else:\\n            w, val = next_w, next_val\\n            \\nprint '{:.6f}'.format(BGD_multi_step(target_f, gradient_f, x, y))\\n\\n%%timeit\\nBGD_multi_step(target_f, gradient_f, x, y)\\n\\ndef BGD(target_f, gradient_f, x, y, toler = 1e-6, alpha=0.01):\\n    w = random.random()\\n    val = target_f(x,y,w)\\n    i = 0\\n    while True:\\n        i += 1\\n        gradient = gradient_f(x,y,w)\\n        next_w = step(w, gradient, alpha)\\n        next_val = target_f(x,y,next_w)    \\n        if (abs(val - next_val) < toler):\\n            return w\\n        else:\\n            w, val = next_w, next_val\\n            \\nprint '{:.6f}'.format(BGD(target_f, gradient_f, x, y))\\n\\n%%timeit\\nBGD(target_f, gradient_f, x, y)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%matplotlib inline\\n\\nimport matplotlib.pyplot as plt\\n\\n\\nplt.hist([1,2,3])\\nplt.show()\\n\\nimport numpy as np\\n\\nx = np.arange(-20,20,0.1)\\n\\ny = np.sin(x)\\n\\nplt.plot(x,y)\\n\\na = tf.constant(100)\\nb = tf.constant(50)\\n\\nadd_op = a + b\\n\\nv = tf.Variable(0)\\nlet_op = tf.assign(v, add_op)\\n\\nwith tf.Session() as sess:\\n    sess.run(tf.global_variables_initializer())\\n    _, v_val = sess.run([let_op,v])\\n    print(v_val)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n마크다운으로 메모 작성하기...!\\n마크 다운으로 메모를 작성합니다.\\n이번 절의 목표\\n\\njupyter notebook\\n시각적으로 기계 학습 살펴보기\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"06_image-classification\\/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    height = int(x_tensor.shape[1])\\n    deviation = 1\\/np.sqrt(num_outputs)\\n    \\n    W = tf.Variable(tf.truncated_normal([height, num_outputs],\\n                                        mean=0.0, stddev=deviation))\\n    b = tf.Variable(tf.truncated_normal([num_outputs],\\n                                        mean=0.0, stddev=deviation))\\n    fc1 = tf.add(tf.matmul(x_tensor, W), b)\\n    return tf.nn.relu(fc1)\\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\":\"%%cython\\n\\nimport numpy as np\\n\\ncimport cython\\ncimport numpy as np\\n\\ndef feed_backward_comb_filter(signal, tau, alpha):\\n    \\\"\\\"\\\"\\n    Filter the signal with a feed backward comb filter.\\n\\n    :param signal: signal\\n    :param tau:    delay length\\n    :param alpha:  scaling factor\\n    :return:       comb filtered signal\\n\\n    \\\"\\\"\\\"\\n    if signal.ndim == 1:\\n        return feed_backward_comb_filter_1d(signal, tau, alpha)\\n    elif signal.ndim == 2:\\n        return feed_backward_comb_filter_2d(signal, tau, alpha)\\n    else:\\n        raise ValueError('signal must be 1d or 2d')\\n\\n@cython.boundscheck(False)\\ndef feed_backward_comb_filter_1d(np.ndarray[np.float_t, ndim=1] signal,\\n                                 unsigned int tau,\\n                                 float alpha):\\n    \\\"\\\"\\\"\\n    Filter the signal with a feed backward comb filter.\\n\\n    :param signal: signal\\n    :param tau:    delay length\\n    :param alpha:  scaling factor\\n    :return:       comb filtered signal\\n\\n    \\\"\\\"\\\"\\n    # y[n] = x[n] + α * y[n - τ]\\n    if tau <= 0:\\n        raise ValueError('tau must be greater than 0')\\n    # type definitions\\n    cdef np.ndarray[np.float_t, ndim=1] y = np.copy(signal)\\n    cdef unsigned int n\\n    # loop over the complete signal\\n    for n in range(tau, len(signal)):\\n        # add a delayed version of the output signal\\n        y[n] += alpha * y[n - tau]\\n    # return the filtered signal\\n    return y\\n\\n@cython.boundscheck(False)\\ndef feed_backward_comb_filter_2d(np.ndarray[np.float_t, ndim=2] signal,\\n                                 unsigned int tau,\\n                                 float alpha):\\n    \\\"\\\"\\\"\\n    Filter the signal with a feed backward comb filter.\\n\\n    :param signal: signal\\n    :param tau:    delay length\\n    :param alpha:  scaling factor\\n    :return:       comb filtered signal\\n\\n    \\\"\\\"\\\"\\n    # y[n] = x[n] + α * y[n - τ]\\n    if tau <= 0:\\n        raise ValueError('tau must be greater than 0')\\n    # type definitions\\n    cdef np.ndarray[np.float_t, ndim=2] y = np.copy(signal)\\n    cdef unsigned int d, n\\n    # loop over the dimensions\\n   ...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nOk, we are now on par with the feed forward Numpy variant -- or even a bit better :)\\nTo get back the flexibility of the Python\\/Numpy solution to be able to handle signals of arbitrary dimension, we need to define a wrapper function (in pure Python):\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Define function hyperparameters\\nbatch_size = \\nimg_size = \\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\n# Call your function and get a dataloader\\nceleba_train_loader = get_dataloader(batch_size, img_size)\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreate a DataLoader\\nExercise: Create a DataLoader celeba_train_loader with appropriate hyperparameters.\\nCall the above function and create a dataloader to view images. \\n* You can decide on any reasonable batch_size parameter\\n* Your image_size must be 32. Resizing the data to a smaller size will make for faster training, while still creating convincing images of faces!\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<img src=\\\"image\\/Mean_Variance_Image.png\\\" style=\\\"height: 75%;width: 75%; position: relative; right: 5%\\\">\\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    a, b = 0.1, 0.9\\n    min_value, max_value = 0, 255\\n    \\n    return a + ((image_data - min_value) * (b - a)) \\/ (max_value - min_value)\\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,...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Lesson14\\/Twitter assignment.ipynb\\\".\\nThe first task is:\\nTwitter authentication (fill this!)\\nCan you write Python code for it?\\n\",\"targets\":\"\\nAPP_KEY = \\\"\\\"\\nAPP_SECRET = \\\"\\\"\\nOAUTH_TOKEN = \\\"\\\"\\nOAUTH_TOKEN_SECRET = \\\"\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%time model.train(train_corpus)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nEssentially, the vocabulary is a dictionary (accessible via model.wv.vocab) of all of the unique words extracted from the training corpus along with the count (e.g., model.wv.vocab['penalty'].count for counts for the word penalty).\\nTime to Train\\nIf the BLAS library is being used, this should take no more than 3 seconds.\\nIf the BLAS library is not being used, this should take no more than 2 minutes, so use BLAS if you value your time.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Compute the invariant mass\\nThis computes the 4-vectors sum for the 4-lepton system\\nusing formulas from special relativity.\\nSee also http:\\/\\/edu.itp.phys.ethz.ch\\/hs10\\/ppp1\\/2010_11_02.pdf\\nand https:\\/\\/en.wikipedia.org\\/wiki\\/Invariant_mass\\n\",\"targets\":\"# This computes the 4-vectors sum for the 4-lepton system\\n\\ndf_4lep = df_lep_filtered.selectExpr(\\n\\\"lep.lep_pt[0] * cos(lep.lep_phi[0]) + lep.lep_pt[1] * cos(lep.lep_phi[1]) + lep.lep_pt[2] * cos(lep.lep_phi[2]) + lep.lep_pt[3] * cos(lep.lep_phi[3]) as Px\\\",\\n\\\"lep.lep_pt[0] * sin(lep.lep_phi[0]) + lep.lep_pt[1] * sin(lep.lep_phi[1]) + lep.lep_pt[2] * sin(lep.lep_phi[2]) + lep.lep_pt[3] * sin(lep.lep_phi[3]) as Py\\\",\\n\\\"lep.lep_pt[0] * sinh(lep.lep_eta[0]) + lep.lep_pt[1] * sinh(lep.lep_eta[1]) + lep.lep_pt[2] * sinh(lep.lep_eta[2]) + lep.lep_pt[3] * sinh(lep.lep_eta[3]) as Pz\\\",\\n\\\"lep.lep_E[0] + lep.lep_E[1] + lep.lep_E[2] + lep.lep_E[3] as E\\\"  \\n)\\n\\ndf_4lep.show(5)\\n\\ndf_4lep_invmass = df_4lep.selectExpr(\\\"sqrt(E * E - ( Px * Px + Py * Py + Pz * Pz))\\/1e3 as invmass_GeV\\\")\\n\\ndf_4lep_invmass.show(5)\\n\\n# This defines the DataFrame transformation to compute the histogram of invariant mass\\n# The result is a histogram with (energy) bin values and event counts foreach bin\\n\\n# Requires sparkhistogram\\n# See https:\\/\\/github.com\\/LucaCanali\\/Miscellaneous\\/blob\\/master\\/Spark_Notes\\/Spark_DataFrame_Histograms.md \\nfrom sparkhistogram import computeHistogram\\n\\n# histogram parameters\\nmin_val = 80\\nmax_val = 250\\nnum_bins = (max_val - min_val) \\/ 5.0\\n\\n# use the helper function computeHistogram in the package sparkhistogram\\nhistogram_data = computeHistogram(df_4lep_invmass, \\\"invmass_GeV\\\", min_val, max_val, num_bins) \\n\\n\\n# The action toPandas() here triggers the computation.\\n# Histogram data is fetched into the driver as a Pandas Dataframe.\\n\\n%time histogram_data_pandas=histogram_data.toPandas()\\n\\n\\nimport numpy as np\\n\\n# Computes statistical error on the data (histogram)\\nhistogram_data_stat_errors = np.sqrt(histogram_data_pandas)\\n\\n# This plots the data histogram with error bars\\n\\nimport matplotlib.pyplot as plt \\n\\nplt.style.use('seaborn-darkgrid')\\nplt.rcParams.update({'font.size': 20, 'figure.figsize': [14,10]})\\n\\nf, ax = plt.subplots()\\n\\nx = histogram_data_pandas[\\\"value\\\"]\\ny = histogram_data_pandas[\\\"count\\\"]\\nerr = histogram_data_stat_errors[\\\"count\\\"]\\n\\n# scatter...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Show the plot.\\npl.plot(setosa_petal_length, m * setosa_petal_length + c, 'b-')\\npl.plot(setosa_petal_length, setosa_petal_width, 'k.')\\npl.xlabel('setosa_petal_length')\\npl.ylabel('setosa_petal_width')\\npl.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCompare to values of $m$ & $c$ we got earlier:\\nm is 0.189262 and c is -0.033080.\\n(almost equivalent)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<b>You can check the status of the job and other information on <a href=\\\"https:\\/\\/console.cloud.google.com\\/mlengine\\/jobs\\\">GCP CloudML page<\\/a> <\\/b>\\n<b> 2h. View the prediction (output) generated by the inference job <\\/b>\\n\",\"targets\":\"%%bash\\ngsutil cat ${INFERENCE_PATH}\\/prediction.results-00000-of-00001\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<span style=\\\"color:red\\\">Assignment (2 min):<\\/span> In the cell below add the code to knockout the gene and see what happens. Does the result make sense?\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n### KNOCKOUT THE GENE HERE\\n\\nfbasol = pfba(model)\\nfvasol = cobra.flux_analysis.flux_variability_analysis(model,reaction_list=rxnsOfInterest,fraction_of_optimum=0,remove_cycles=True)\\nfvasol\\n\\nb = show_map(fbasol,map_loc)\\nb.display_in_notebook()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"14.3. Aerosol Species\\nIs Required: FALSE&nbsp;&nbsp;&nbsp;&nbsp;Type: ENUM&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 0.N\\nAerosol species included in the stratospheric heterogeneous chemistry scheme.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# PROPERTY ID - DO NOT EDIT !  \\nDOC.set_id('cmip6.atmoschem.stratospheric_heterogeneous_chemistry.aerosol_species')  \\n\\n# PROPERTY VALUE(S): \\n# Set as follows: DOC.set_value(\\\"value\\\")  \\n# Valid Choices: \\n#      \\\"Sulphate\\\"  \\n#      \\\"Polar stratospheric ice\\\"  \\n#      \\\"NAT (Nitric acid trihydrate)\\\"  \\n#      \\\"NAD (Nitric acid dihydrate)\\\"  \\n#      \\\"STS (supercooled ternary solution aerosol particule))\\\"  \\nDOC.set_value(\\\"NAT (Nitric acid trihydrate)\\\")  \\nDOC.set_value(\\\"Polar stratospheric ice\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Clean up, Clean up...\\nUse of low level segmentation algorithms such as region growing is often followed by a clean up step. In this step we fill holes and remove small connected components. Both of these operations are achieved by using binary morphological operations, opening (BinaryMorphologicalOpening) to remove small connected components and closing (BinaryMorphologicalClosing) to fill holes.\\nSimpleITK supports several shapes for the structuring elements (kernels) including:\\n* sitkAnnulus\\n* sitkBall\\n* sitkBox\\n* sitkCross\\nThe size of the kernel can be specified as a scalar (same for all dimensions) or as a vector of values, size per dimension.\\nThe following code cell illustrates the results of such a clean up, using closing to remove holes in the original segmentation.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nvectorRadius = (1, 1, 1)\\nkernel = sitk.sitkBall\\nseg_implicit_thresholds_clean = sitk.BinaryMorphologicalClosing(\\n    seg_implicit_thresholds, vectorRadius, kernel\\n)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"% ll dadiExercises\\/\\n\\n% cat dadiExercises\\/ERY.FOLDED.sfs.dadi_format\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLoad 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 \\\"01-Container.ipynb\\\".\\nThe first task is:\\nsome functions about array\\nCan you write Python code for it?\\n\",\"targets\":\"\\na.ndim      # rank of an array\\n\\na.shape       # dimension or shape of an array (result is a tuple)\\n\\na.size       # total number of items\\n\\na.dtype       # type of item (rq. array里面所有item都是同样的类型)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Colors for the bar plot\\nCOLORS = ['orange', 'green', 'orange', 'cyan', 'cyan', 'blue', 'silver', 'orange', 'red', 'green']\\n\\n# Plotting market_cap_usd as before but adding the colors and scaling the y-axis  \\nax = cap10.plot.bar(x='id',y='market_cap_perc',title=TOP_CAP_TITLE, color=COLORS, log=True)\\n\\n# Annotating the y axis with 'USD'\\nax.set_ylabel(\\\"USD\\\")\\n\\n# Final touch! Removing the xlabel as it is not very informative\\nax.set_xlabel('')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n4. Making the plot easier to read and more informative\\n<p>While the plot above is informative enough, it can be improved. Bitcoin is too big, and the other coins are hard to distinguish because of this. Instead of the percentage, let's use a log<sup>10<\\/sup> scale of the \\\"raw\\\" capitalization. Plus, let's use color to group similar coins and make the plot more informative<sup>1<\\/sup>. <\\/p>\\n<p>For the colors rationale: bitcoin-cash and bitcoin-gold are forks of the bitcoin <a href=\\\"https:\\/\\/en.wikipedia.org\\/wiki\\/Blockchain\\\">blockchain<\\/a><sup>2<\\/sup>. Ethereum and Cardano both offer Turing Complete <a href=\\\"https:\\/\\/en.wikipedia.org\\/wiki\\/Smart_contract\\\">smart contracts<\\/a>. Iota and Ripple are not minable. Dash, Litecoin, and Monero get their own color.<\\/p>\\n<p><sup>1<\\/sup> <em>This coloring is a simplification. There are more differences and similarities that are not being represented here.<\\/em><\\/p>\\n<p><sup>2<\\/sup> <em>The bitcoin forks are actually <strong>very<\\/strong> different, but it is out of scope to talk about them here. Please see the warning above and do your own research.<\\/em><\\/p>\",\"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_2D_acoustic_FD_modelling\\/lecture_notebooks\\/4_fdac2d_absorbing_boundary.ipynb\\\".\\nThe first task is:\\nHomogeneous block model without absorbing boundary frame\\nAs a reference, we first model the homogeneous block model, defined in the function model, without an absorbing boundary frame:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Homogeneous model\\ndef model(nx,nz,vp,dx,dz):\\n    \\n    vp += vp0 \\n    \\n    return vp\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#coordinate transformation\\norigin_new_x=0            # A point in Fig 1\\norigin_new_y=0            \\n\\nX_local=X-origin_new_x\\nY_local=Y-origin_new_y\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLine segment source integration\\nLine source solution for pressure and velocity (Datta-Gupta, 2007)\\n\\\\begin{equation}\\nP(x,y)=B{{Q}{w}}=-\\\\frac{70.60\\\\mu }{h\\\\sqrt{{{k}{x}}{{k}{y}}}}\\\\ln \\\\left{ {{(x-{{x}{w}})}^{2}}+\\\\frac{{{k}{x}}}{{{k}{y}}}{{(y-{{y}{w}})}^{2}} \\\\right}{{Q}{w}}+{{P}_{avg}}\\n\\\\end{equation}\\n\\\\begin{equation}\\n\\\\frac{\\\\partial P}{\\\\partial x}=u=\\\\frac{0.8936}{h\\\\phi }\\\\sqrt{\\\\frac{{{k}{x}}}{{{k}{y}}}}\\\\sum\\\\limits_{k=1}^{{{N}{w}}}{{{Q}{k}}}\\\\frac{x-{{x}{k}}}{{{\\\\left( x-{{x}{k}} \\\\right)}^{2}}+\\\\frac{{{k}{x}}}{{{k}{y}}}{{(y-{{y}_{k}})}^{2}}}\\n\\\\end{equation}\\n\\\\begin{equation}\\n\\\\frac{\\\\partial P}{\\\\partial y}=v=\\\\frac{0.8936}{h\\\\phi }\\\\sqrt{\\\\frac{{{k}{x}}}{{{k}{y}}}}\\\\sum\\\\limits_{k=1}^{{{N}{w}}}{{{Q}{k}}}\\\\frac{y-{{y}{k}}}{{{\\\\left( x-{{x}{k}} \\\\right)}^{2}}+\\\\frac{{{k}{x}}}{{{k}{y}}}{{(y-{{y}_{k}})}^{2}}}\\n\\\\end{equation}\\nLocal coordinate transformation\\n<img src=\\\".\\/resources\\/PanelLocal.png\\\" width=\\\"300\\\">\\n<center>Figure 1. Nomenclature of the boundary element in the local coordinates<\\/center>\\nBased on the nomenclatures in Fig. 1, a boundary element could be determined as its start point (A), end point (B), length (lj) and inclination (αj). The coordinate transformation from global system to local system can be given as follows:\\n\\\\begin{matrix}\\n   {x}'=x-{{x}{A}} & {y}'=y-{{y}{A}}  \\\\\\n\\\\end{matrix}\\nWhere (xA,yA) is the location of start point (point A in Fig. A-1) of a BE in global coordinate system. Trigonometric sine and cosine function for a BE could be determined from start point (A) and end point (B) of the boundary elements, which can be expressed as follows:\\n\\\\begin{matrix}\\n   \\\\sin {{\\\\alpha }{j}}=\\\\frac{{{y}{B}}-{{y}{A}}}{{{l}{j}}} & \\\\cos {{\\\\alpha }{j}}=\\\\frac{{{x}{B}}-{{x}{A}}}{{{l}{j}}}  \\\\\\n\\\\end{matrix}\\nIn local coordinate system, line source are placed along the boundary element at a point (x’j,y’j). The location can be easily given as follows:\\n\\\\begin{equation}\\n\\\\begin{matrix}\\n   \\\\begin{matrix}\\n   {{{{x}'}}{j}}=t\\\\cos {{\\\\alpha }{j}} & {{{{y}'}}{j}}=t\\\\sin {{\\\\alpha }{j}}  \\\\\\n\\\\end{matrix} & 0\\\\le t  \\\\\\n\\\\end{matrix}\\\\le {{l}_{j}}\\n\\\\end{equation}\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Below, we create our smarter index (based on a subset of the documents for demonstration purposes)\\nsmarter_index = defaultdict(set)\\n\\n# Here we define the subset (somewhat arbitrary):\\nsubset_of_ids = set(key for key in Abstracts.keys() if 24100000 <= key < 24200000)\\nsubset_of_abstracts = ((key, Abstracts[key]) for key in subset_of_ids)\\n\\n# Uncomment this line to process the whole corpus (might take a long time):\\n#subset_of_abstracts = Abstracts.items()\\n\\n# Building our smarter index:\\nfor (id, abstract) in subset_of_abstracts:\\n    for term in smarter_preprocess(smarter_tokenize(abstract)):\\n        smarter_index[term].add(id)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow we can make a smarter index based on these functions. For practical purposes, the code below generates the smarter index on a subset of the data, as generating an index with stemming on the entire set would take too much time. (You don't need to change or add anything here.)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Also, we can write the game out in the XML format used by Game Theory Explorer:\\n\",\"targets\":\"print g.write('gte')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"(2) _config.yml\\n\",\"targets\":\"%%writefile _config.yml\\nname: Ruxi\\nmarkdown:\\n\\nApprently karmdown is the only flavor of\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"### Type your commands in this cell and then run using SHIFT-ENTER.\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n2) Simulate 5 sequences of 3 coin flips each.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Mention\\/Mention_example.ipynb\\\".\\nThe first task is:\\nA scatterplot is used to get how an article is positioned according to these two variables. The plot shows:\\n* IT: when the mentions are equal to 1 the number of page views is spread between 0 and ~20k. Where the number of mentions increases the number of page visualizations belongs to a smaller range. \\n* PT: also for Portuguese article the same is observed.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# def scatter_plot(df_it_mension_pageview, df_pt_mension_pageview, 'Number of mentions', 'Pageviews', 'Italian', 'Portuguese')\\ntls.embed('https:\\/\\/plot.ly\\/~crimenghini\\/36')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Macro average, with min mae.\\n\\ncalculate_mape_apply_fn_args = {\\n    'average_type': 'macro', \\n    'expected_num_locations': 47,\\n    'min_mae': 10.0,\\n    'min_count': None,\\n    'value_type': 'daily',\\n}\\n\\n# Prospective.\\njp_prosp_confirmed_xs, jp_prosp_confirmed_ys = calculate_mape(\\n    jp_prosp_confirmed_df, calculate_mape_apply_fn_args)\\njp_prosp_deaths_xs, jp_prosp_deaths_ys = calculate_mape(\\n    jp_prosp_deaths_df, calculate_mape_apply_fn_args)\\n\\nplt.figure(figsize=(16, 6))\\n# Plot prospective.\\nplt.plot(jp_prosp_confirmed_xs, jp_prosp_confirmed_ys, label='confirmed, prospective', \\n         marker='o', color='b')\\nplt.plot(jp_prosp_deaths_xs, jp_prosp_deaths_ys, label='deaths, prospective', \\n          marker='o', color='g')\\n\\n# Formatting.\\nplt.grid()\\nplt.legend()\\nplt.xlabel('train date')\\nplt.ylabel('MAPE')\\nplt.title(f'MAPE vs training date (>= {calculate_mape_apply_fn_args[\\\"min_mae\\\"]} MAE)')\\nplt.show()\\n\\nprint_mape_stats(\\n    avg_type='Macro average, with mae threshold', \\n    locale='Japan', \\n    prosp_confirmed_ys=jp_prosp_confirmed_ys, \\n    prosp_deaths_ys=jp_prosp_deaths_ys)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPlot macro average, with min mae.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"And, a convenience method for constructing Scheme-like lists of multiple items:\\n\",\"targets\":\"List(1, 2, 3, 4)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# set the mutation rate\\nga.mutationRate = 0.01 # this means 1% of the elements will get it\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLarge values of $\\\\tau$ will cause elements with low fitness to be almost never selected. This will make the GA \\\"converge\\\" faster, halting evolution.\\nSmall values of $\\\\tau$ will eventually give equal chance to all elements regardless of their fitness. This will slow down the evolution.\\nYou will have to find a good compromise!\\nMutating elements\\nOccasionally, mutation can appear when mixing two elements. There are several ways to implement mutations, but here we stick to simplicity. A mutation adds a random value to one random gene of the element. <br>\\nMutations should be rare or they will mess up the evolution!\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Conclusion\\nAs can be seen from the visualization and also from the dataframe table above - 1st Class passengers had highest rate of survival, then 2nd class passengers, and the least survival rates was of 3rd class passengers. A large number of passengers were travelling in 3rd class (491), but only 24.24% survived.\\nQuestion 2 - Which gender had more survival?\\n\",\"targets\":\"## CALCULATE SURVIVED AND TOTAL BY SEX\\n\\n# groupby Sex\\ngroup_by_sex = titanic_df.groupby('Sex')\\n\\n# calculate survived by sex\\nsurvived_by_sex = group_by_sex['Survived'].sum()\\nsurvived_by_sex.name = 'Survived'\\ndisplay(survived_by_sex)\\n\\n# calculate total by sex\\ntotal_by_sex = group_by_sex['Survived'].size()\\ntotal_by_sex.name = 'Total'\\ndisplay(total_by_sex)\\n\\n# concat the separate results into one dataframe\\nsurvived_total_by_sex = pd.concat([survived_by_sex, total_by_sex], axis=1)\\nsurvived_total_by_sex\\n\\npercent_survived = (survived_total_by_sex['Survived'] \\/ survived_total_by_sex['Total']) * 100\\nsurvived_total_by_sex['Percentage'] = percent_survived\\n\\nsurvived_total_by_sex\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2.4 Answer\\nThat eigenvector results in all derivatives being $0$, meaning the concentrations do not change\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint(c_mat.dot(e_v[:,2]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Classifier #1 Perceptron\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.linear_model import Perceptron\\nfrom sklearn.metrics import accuracy_score\\n\\n# Training\\nppn = Perceptron(n_iter=800, eta0=0.1, random_state=0)\\nppn.fit(X_train, y_train)\\n# Testing\\ny_pred = ppn.predict(X_test)\\n# Results\\nprint('Misclassified samples: %d out of %d' % ((y_test != y_pred).sum(), y_test.shape[0]))\\nprint('Accuracy: %.3f' % accuracy_score(y_test, y_pred))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%javascript\\nrequire([\\\"widgets\\/js\\/widget\\\", \\\"widgets\\/js\\/manager\\\"], function(widget, manager){\\n    \\n});\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nsync=True traitlets\\nTraitlets is an IPython library for defining type-safe properties on configurable objects.  For this tutorial you do not need to worry about the configurable piece of the traitlets machinery.   The sync=True keyword argument tells the widget framework to handle synchronizing that value to the front-end.  Without sync=True, the front-end would have no knowledge of _view_name.\\nOther traitlet types\\nUnicode, used for _view_name, is not the only Traitlet type, there are many more some of which are listed below:  \\n\\nAny\\nBool\\nBytes\\nCBool\\nCBytes\\nCComplex\\nCFloat\\nCInt\\nCLong\\nCRegExp\\nCUnicode\\nCaselessStrEnum\\nComplex\\nDict\\nDottedObjectName\\nEnum\\nFloat\\nFunctionType\\nInstance\\nInstanceType\\nInt\\nList\\nLong\\nSet\\nTCPAddress\\nTuple\\nType\\nUnicode\\nUnion\\n\\nNot all of these traitlets can be synchronized across the network, only the JSON-able traits and Widget instances will be synchronized.\\nFront-end (JavaScript)\\nModels and views\\nThe IPython widget framework front-end relies heavily on Backbone.js.  Backbone.js is an MVC (model view controller) framework.  Widgets defined in the back-end are automatically synchronized with generic Backbone.js models in the front-end.  The traitlets are added to the front-end instance automatically on first state push.  The _view_name trait that you defined earlier is used by the widget framework to create the corresponding Backbone.js view and link that view to the model.\\nImport the WidgetManager\\nYou first need to import the widget and manager modules.  You will use the manager later to register your view by name (the same name you used in the back-end).  To import the modules, use the require method of require.js (as seen below).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"12. 추정 및 검정\\/06. MLE 모수 추정.ipynb\\\".\\nThe first task is:\\n다변수 정규 분포의 모수 추정\\nMLE for Multivariate Gaussian Normal Distribution\\n\\n각각의 시도 $x_i$에 대한 확률은 다변수 정규 분포\\n\\n$$ p(x ; \\\\theta ) = N(x ; \\\\mu, \\\\Sigma) = \\\\dfrac{1}{(2\\\\pi)^{D\\/2} |\\\\Sigma|^{1\\/2}} \\\\exp \\\\left( -\\\\dfrac{1}{2} (x-\\\\mu)^T \\\\Sigma^{-1} (x-\\\\mu) \\\\right) $$\\n\\n\\n$N$개의 독립 샘플 $x_{1:N}$ 이 있는 경우, \\n$$ L(\\\\theta;x_{1:N}) = p(x_{1:N};\\\\theta) = \\\\prod_{i=1}^N  \\\\dfrac{1}{(2\\\\pi)^{D\\/2} |\\\\Sigma|^{1\\/2}} \\\\exp \\\\left( -\\\\dfrac{1}{2} (x_i-\\\\mu)^T \\\\Sigma^{-1} (x_i-\\\\mu) \\\\right)$$\\n\\n\\nLog-Likelihood\\n$$ \\n\\\\begin{eqnarray}\\n\\\\log L \\n&=& \\\\log P(x_{1:N};\\\\theta)  \\\\\\n&=& \\\\sum_{i=1}^N \\\\left{ -\\\\log((2\\\\pi)^{D\\/2} |\\\\Sigma|^{1\\/2}) - \\\\dfrac{1}{2} (x-\\\\mu)^T \\\\Sigma^{-1} (x-\\\\mu) \\\\right} \\\\\\n&=& C -\\\\dfrac{N}{2} \\\\log|\\\\Sigma| - \\\\dfrac{1}{2} \\\\sum (x-\\\\mu)^T \\\\Sigma^{-1} (x-\\\\mu) \\n\\\\end{eqnarray}\\n$$\\n\\n\\nprecision matrix $\\\\Lambda = \\\\Sigma^{-1}$\\n\\n\\n$$ \\n\\\\begin{eqnarray}\\n\\\\log L \\n&=& C + \\\\dfrac{N}{2} \\\\log|\\\\Lambda| - \\\\dfrac{1}{2} \\\\sum(x-\\\\mu)^T \\\\Lambda (x-\\\\mu) \\n\\\\end{eqnarray}\\n$$\\n$$ \\\\dfrac{\\\\partial L}{\\\\partial \\\\mu} = -  \\\\dfrac{\\\\partial}{\\\\partial \\\\mu}  \\\\sum_{i=1}^N (x_i-\\\\mu)^T \\\\Lambda (x_i-\\\\mu) =  \\\\sum_{i=1}^N 2\\\\Lambda (x_i - \\\\mu) = 0 $$\\n$$ \\\\mu = \\\\dfrac{1}{N}\\\\sum_{i=1}^N x_i $$\\n$$ \\\\dfrac{\\\\partial L}{\\\\partial \\\\Lambda} = \\\\dfrac{\\\\partial}{\\\\partial \\\\Lambda} \\\\dfrac{N}{2} \\\\log|\\\\Lambda| - \\\\dfrac{\\\\partial}{\\\\partial \\\\Lambda}  \\\\dfrac{1}{2} \\\\sum_{i=1}^N \\\\text{tr}( (x_i-\\\\mu)(x_i-\\\\mu)^T\\\\Lambda) =0  $$\\n$$ \\\\dfrac{N}{2} \\\\Lambda^{-T} = \\\\dfrac{1}{2}\\\\sum_{i=1}^N (x_i-\\\\mu)(x_i-\\\\mu)^T $$ \\n$$ \\\\Sigma = \\\\dfrac{1}{N}\\\\sum_{i=1}^N (x_i-\\\\mu)(x_i-\\\\mu)^T $$\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnp.random.seed(0)\\nmu0 = np.array([0, 1])\\nsigma0 = np.array([[1, 0.2], [0.2, 4]])\\nx = sp.stats.multivariate_normal(mu0, sigma0).rvs(1000)\\nxbar = x.mean(axis=0)\\nS2 = np.cov(x, rowvar=0)\\nprint(xbar)\\nprint(S2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"$\\\\Delta^{MTE}$ is constant in the absence of essential heterogeneity whereas decreasing respectively increasing values indicate the presence of essential heterogeneity. Why?\\n\\n\\nAdditionally whether $\\\\Delta^{MTE}$ is increasing or decreasing along $u_D$ provides information about which kind of selection on gains take place\\n\\n\\nIn addition it is also possible to derive all conventional effects from $\\\\Delta^{MTE}$ by applying effect specific weights along the distribution of $V$:\\n\\n\\n\\\\begin{align}\\n\\\\omega^{ATE}(x,u_D) &= 1.0\\\\\\n\\\\omega^{TT}(x,u_D) &= \\\\frac{\\\\int_{u_D}^{1}f(p|X=x)dp}{E[P|X=x]}\\\\\\n\\\\omega^{TUT}(x,u_D) &= \\\\frac{\\\\int_{0}^{u_D}f(p|X=x)dp}{E[1-P|X=x]}\\\\\\n\\\\end{align}\\nFormally:\\n\\\\begin{align}\\n\\\\Delta^j = \\\\int_0^1 \\\\omega_j(x,u_D) \\\\Delta^{MTE}(x,u_D)du_D\\\\\\n\\\\text{ for } j = \\\\text{ ATE, TT, TUT}\\n\\\\end{align}\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# assign parameter and choice covariates\\ngamma = spec_eh['CHOICE']['params']\\nZ = df_eh[spec_eh['CHOICE']['order']]\\n\\n# compute average propensity score as well as individual propensity score\\npropensity_mean = np.mean(norm.cdf(np.dot(gamma, Z.T)))\\nauxiliary = norm.cdf(np.dot(gamma, Z.T))\\n\\n# compute the integral\\nintegral_TT = np.array([sum(auxiliary > quantiles[i])\\/ Z.shape[0]  for i in range(len(quantiles))]) \\nintegral_TUT = np.array( [1 - (sum(auxiliary > quantiles[i])\\/ Z.shape[0])  for i in range(len(quantiles))]) \\n\\n# compute the weights\\nomega_TT = integral_TT \\/ propensity_mean\\nomega_TUT = integral_TUT \\/ ( 1- propensity_mean)\\nomega_ATE = [1.0] * len(quantiles)\\n\\n\\n# plot\\nax1 = plt.figure(figsize=(15, 10)).add_subplot(111)\\n\\nplt.ylabel(r\\\"$\\\\Delta^{MTE}$\\\", fontsize=24)\\nplt.xlabel(\\\"$u_D$\\\", fontsize=24)\\nax1.plot(quantiles, mte, color='blue', label=' $\\\\Delta^{MTE}$', linewidth=3.0)\\nax2 = ax1.twinx()\\n\\n\\nax2.plot(quantiles, omega_TT, color='red', linestyle='--', label=' $\\\\omega^{TT}$', linewidth=3.0)\\n\\nax2.plot(quantiles, omega_TUT, color='green', linestyle='--', label=' $\\\\omega^{TUT}$', linewidth=3.0)\\n\\nax2.plot(quantiles, omega_ATE, color='orange', linestyle= '-.', label=' $\\\\omega^{ATE}$', linewidth=3.0)\\n\\nplt.legend(prop={\\\"size\\\": 20})\\n\\nstring = \\\"      True Values  Weighted Values\\\\n\\\\nATE:{0:>10.5f}{3:>15.5f}\\\\nTT:{1:>11.5f}{4:>15.5f}\\\\nTUT:{2:>10.5f}{5:>15.5f}\\\"\\n\\n# Apply weights to the mte\\nATE_w = np.mean(np.multiply(np.array(mte), omega_ATE))\\nTT_w = np.mean(np.multiply(np.array(mte), omega_TT))\\nTUT_w = np.mean(np.multiply(np.array(mte), omega_TUT))\\neffects = [ATE, TT, TUT, ATE_w, TT_w, TUT_w]\\n\\n# print comparison to the true values\\nprint(string.format(*effects))\\n\\nprint('\\\\n\\\\n\\\\nNaive comparison: {:.5f}'.format(effect_estimate))\",\"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\\/fti.ipynb\\\".\\nThe first task is:\\nAs always, let's do imports and initialize a logger and a new bundle.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport phoebe\\nfrom phoebe import u # units\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\n\\nlogger = phoebe.logger()\\n\\nb = phoebe.default_binary()\\n\\nb.add_dataset('lc', times=np.linspace(0,1,101), dataset='lc01')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2.A.2. Automated Collection\\nProcedure: Scripted search of filesystem for document and media files using PowerShell\\nCriteria: powershell.exe executing (Get-)ChildItem\\nDetection Type:Telemetry(Correlated)\\nQuery ID:F96EA21C-1EB4-4988-8F98-BD018717EE2D\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndf = spark.sql(\\n'''\\nSELECT b.ScriptBlockText\\nFROM apt29Host a\\nINNER JOIN (\\n  SELECT d.ParentProcessGuid, d.ProcessId, c.ScriptBlockText\\n  FROM apt29Host c\\n  INNER JOIN (\\n      SELECT ParentProcessGuid, ProcessGuid, ProcessId\\n      FROM apt29Host\\n      WHERE Channel = \\\"Microsoft-Windows-Sysmon\\/Operational\\\"\\n          AND EventID = 1\\n      ) d\\n  ON c.ExecutionProcessID = d.ProcessId\\n  WHERE c.Channel = \\\"Microsoft-Windows-PowerShell\\/Operational\\\"\\n          AND c.EventID = 4104\\n          AND LOWER(c.ScriptBlockText) LIKE \\\"%childitem%\\\"\\n) b\\nON a.ProcessGuid = b.ParentProcessGuid\\nWHERE a.Channel = \\\"Microsoft-Windows-Sysmon\\/Operational\\\"\\n          AND a.EventID = 1\\n          AND LOWER(a.ParentImage) RLIKE '.*\\\\\\\\‎|â€|‪|‫|‬|â€|‮.*'\\n\\n'''\\n)\\ndf.show(100,truncate = False, vertical = True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Check data exists\\nVerify that you previously created CSV files we'll be using for training and evaluation.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%%bash\\ngsutil ls gs:\\/\\/${BUCKET}\\/babyweight\\/data\\/*000000000000.csv\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#Calculate the correlation matrix\\nresult.corr()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nQuestion 1: Is there a relationship between GDP and Household\\nconsumption? Is it the same across continents?\\nWhen comparing the data sets without grouping the data into continents, the correlation matrix below shows that there is no correlation between years GDP and Electricity consumption, hence there is no inflation effect on the variables. There is a strnger correlation between the standard GDP and the years due to the impact of population.\\nThe table below highlights the positive and strong relationship between electricity consumption and GDP. Furthermore, it evidences the relationship between our standardized variables: both vary in the same direction but at a lower rate due to the impact in the variable “Population” used to standardize them. It also evidences the positive relationship between population and electricity consumption. As expected, it shows that only half of the increase is due to an increase in population leaving the other half unexplained.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"And here's the cosine of the angle between the output and the ideal output\\n\",\"targets\":\"ideal = sim.data[p_in1]\\nactual = sim.data[p_unbind_out]\\nideal = ideal \\/ np.linalg.norm(ideal, axis=1)[:,None]\\nactual = actual \\/ np.linalg.norm(actual, axis=1)[:,None]\\nprod = ideal*actual\\ncos_a = np.sum(prod, axis=1)\\ncos_a[np.isnan(cos_a)] = 0\\npylab.plot(sim.trange(), nengo.synapses.Lowpass(10.0).filt(cos_a, dt=0.001))\\npylab.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Bootstrap to fill all interfaces\\nNow we actually run the bootstrapping calculation. The full_bootstrap function requires an initial snapshot in the state, and then it will generate trajectories satisfying TIS ensemble for the given interfaces. To fill all the ensembles in the MSTIS network, we need to do this once for each initial state.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ninitA = toys.Snapshot(\\n    coordinates=np.array([[-0.5, -0.5]]), \\n    velocities=np.array([[1.0,0.0]]),\\n)\\nbootstrapA = paths.FullBootstrapping(\\n    transition=mstis.from_state[stateA],\\n    snapshot=initA,\\n    engine=toy_eng,\\n    extra_interfaces=[ms_outers.volume_for_interface_set(interfacesA)]\\n)\\ngsA = bootstrapA.run()\\n\\ninitB = toys.Snapshot(\\n    coordinates=np.array([[0.5, -0.5]]), \\n    velocities=np.array([[-1.0,0.0]]),\\n)\\n\\nbootstrapB = paths.FullBootstrapping(\\n    transition=mstis.from_state[stateB], \\n    snapshot=initB, \\n    engine=toy_eng, \\n)\\ngsB = bootstrapB.run()\\n\\ninitC = toys.Snapshot(\\n    coordinates=np.array([[0.0, 0.4]]), \\n    velocities=np.array([[0.0,-0.5]]),\\n)\\nbootstrapC = paths.FullBootstrapping(\\n    transition=mstis.from_state[stateC], \\n    snapshot=initC, \\n    engine=toy_eng, \\n)\\ngsC = bootstrapC.run()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"10 ethnic groups with the largest overall populations (sum of best\\/latest estimates over all countries)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npd.DataFrame(sorted(ethnic_population.items(), key=lambda x:x[1], reverse=True)[:10], columns=['Ethnic_Groups', 'Population'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Alternatively tensors can be indexed using a dictionary of the form tensor[{'dim': slice or int}].\\n\",\"targets\":\"data[{'x': 0, 'y': slice(1, -1), 'vector': '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 \\\"Coursera\\/Machine-learning-data-analysis\\/Course 2\\/Week_03\\/Preprocessing_LR.ipynb\\\".\\nThe first task is:\\nВидно, что тогда мы выбросим почти все данные, и такой метод решения в данном случае не сработает.\\nПропущенные значения можно так же интерпретировать, для этого существует несколько способов, они различаются для категориальных и вещественных признаков.\\nДля вещественных признаков:\\n- заменить на 0 (данный признак давать вклад в предсказание для данного объекта не будет)\\n- заменить на среднее (каждый пропущенный признак будет давать такой же вклад, как и среднее значение признака на датасете)\\nДля категориальных:\\n- интерпретировать пропущенное значение, как ещё одну категорию (данный способ является самым естественным, так как в случае категорий у нас есть уникальная возможность не потерять информацию о наличии пропущенных значений; обратите внимание, что в случае вещественных признаков данная информация неизбежно теряется)\\nЗадание 0. Обработка пропущенных значений.\\n\\nЗаполните пропущенные вещественные значения в X нулями и средними по столбцам, назовите полученные датафреймы X_real_zeros и X_real_mean соответственно. Для подсчёта средних используйте описанную ниже функцию calculate_means, которой требуется передать на вход вешественные признаки из исходного датафрейма.\\nВсе категориальные признаки в X преобразуйте в строки, пропущенные значения требуется также преобразовать в какие-либо строки, которые не являются категориями (например, 'NA'), полученный датафрейм назовите X_cat.\\n\\nДля объединения выборок здесь и далее в задании рекомендуется использовать функции\\nnp.hstack(...)\\nnp.vstack(...)\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef calculate_means(numeric_data):\\n    means = np.zeros(numeric_data.shape[1])\\n    for j in range(numeric_data.shape[1]):\\n        to_sum = numeric_data.iloc[:,j]\\n        indices = np.nonzero(~numeric_data.iloc[:,j].isnull())[0]\\n        correction = np.amax(to_sum[indices])\\n        to_sum \\/= correction\\n        for i in indices:\\n            means[j] += to_sum[i]\\n        means[j] \\/= indices.size\\n        means[j] *= correction\\n    return pd.Series(means, numeric_data.columns)\\n\\nmeans = calculate_means(X[numeric_cols])\\nX_real_zeros = X[numeric_cols]\\nX_real_mean = X[numeric_cols]\\n\\nfor idx, column in enumerate(numeric_cols):\\n    X_real_zeros[column].fillna(0, inplace=True)\\n    X_real_mean[column].fillna(means.iloc[idx], inplace=True)\\n    \\nX_cat = X[categorical_cols]\\nfor column in categorical_cols:\\n    X_cat[column] =  X_cat[column].apply(lambda x: str(x))\\n    X_cat[column] = X_cat[column].fillna('NA')\\nX_cat.info()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# %load _solutions\\/visualization_01_matplotlib4.py\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<div class=\\\"alert alert-success\\\">\\n\\n**EXERCISE 4**\\n\\nPandas supports different types of charts besides line plots, all available from `.plot.xxx`, e.g. `.plot.scatter`, `.plot.bar`,... Make a bar chart to compare the mean discharge in the three measurement stations L06_347, LS06_347, LS06_348. Add a y-label 'mean discharge'. To do so, prepare a Figure and Axes with Matplotlib and add the chart to the created Axes.\\n\\n<details><summary>Hints<\\/summary>\\n\\n* You can either use Pandas `ylabel` parameter to set the label or add it with Matploltib `ax.set_ylabel()`\\n* To link an Axes object with Pandas output, pass the Axes created by `fig, ax = plt.subplots()` as parameter to the Pandas plot function.\\n<\\/details>\\n\\n<\\/div>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%sql -pl values 1,2,3,4,5\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAnd finally a line chart.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"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    \\n\\n### Major steps to consider in you\\n\\n###############################################\\n# Make Stripes from ngrams for systems test 2\\n###############################################\\n\\n!aws s3 rm --recursive s3:\\/\\/ucb261-hw5\\/hw5-4-stripes-mj\\n!python buildStripes.py -r emr mj_systems_test.txt \\\\\\n    --cluster-id=j-2WHMJSLZDGOY5 \\\\\\n    --output-dir=s3:\\/\\/ucb261-hw5\\/hw5-4-stripes-mj \\\\\\n    --file=stopwords.txt \\\\\\n    --file=mostFrequent\\/part-00000 \\\\\\n# Output suppressed\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# %load solutions\\/15A_ridge_grid.py\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<div class=\\\"alert alert-success\\\">\\n    <b>EXERCISE<\\/b>:\\n     <ul>\\n      <li>\\n      Create a pipeline out of a StandardScaler and Ridge regression and apply it to the Boston housing dataset (load using ``sklearn.datasets.load_boston``). Try adding the ``sklearn.preprocessing.PolynomialFeatures`` transformer as a second preprocessing step, and grid-search the degree of the polynomials (try 1, 2 and 3).\\n      <\\/li>\\n    <\\/ul>\\n<\\/div>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Adding genome-wide significant line, and suggestive lines\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmanhattan(     hip_m['f3'], hip_m['f1'], hip_m['f0'].astype(str), 'Hip men',\\n               plot_type='single',\\n               chrs_plot=[str(i) for i in range(1,23)],\\n               chrs_names=chrs_names,\\n               cut = 0,\\n               title='Anthropometric traits',\\n               xlabel='chromosome',\\n               ylabel='-log10(p-value)',\\n               lines= [6, 8],\\n               lines_colors=['b', 'r'],\\n               lines_styles=['-','--'],\\n               lines_widths=[1,2],\\n               colors = colors)\\nplt.savefig('Manhattan_HipMen.png', dpi=300)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"$$\\n\\\\frac{d\\\\mathrm{C}}{dt}=0.01\\\\frac{\\\\mathrm{A}}{V}\\\\frac{\\\\mathrm{B}}{V}-0.3\\\\frac{\\\\mathrm{C}}{V}=0\\\\\\n0.01\\\\left(60-\\\\mathrm{C}\\\\right)^2=0.3\\\\mathrm{C}\\\\times V\\\\\\n\\\\mathrm{C}=30\\n$$\\nYou will obtain almost the same result with ODE or Gillespie (may take longer time than ODE or Gillespie).\\nThis is not surprising because meso module is almost same with Gillespie unless you give additional spatial parameter.\\nNext we will decompose run_simulation.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom ecell4 import *\\n\\nwith reaction_rules():\\n    A + B == C | (0.01, 0.3)\\n\\nm = get_model()\\n\\nw = meso.MesoscopicWorld(Real3(1, 1, 1), Integer3(1, 1, 1))  # XXX: Point2\\nw.bind_to(m)  # XXX: Point1\\nw.add_molecules(Species('C'), 60)\\n\\nsim = meso.MesoscopicSimulator(w)  # XXX: Point1\\nobs = FixedIntervalNumberObserver(0.1, ('A', 'B', 'C'))\\nsim.run(10, obs)\\n\\nviz.plot_number_observer(obs)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"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_decoder_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.\\nTarget sequence length placeholder named \\\"target_sequence_length\\\" with rank 1\\nMax target sequence length tensor named \\\"max_target_len\\\" getting its value from applying tf.reduce_max on the target_sequence_length placeholder. Rank 0.\\nSource sequence length placeholder named \\\"source_sequence_length\\\" with rank 1\\n\\nReturn the placeholders in the following the tuple (input, targets, learning rate, keep probability, target sequence length, max target sequence length, source sequence length)\\n\",\"targets\":\"def model_inputs():\\n    \\\"\\\"\\\"\\n    Create TF Placeholders for input, targets, learning rate, and lengths of source and target sequences.\\n    :return: Tuple (input, targets, learning rate, keep probability, target sequence length,\\n    max target sequence length, source sequence length)\\n    \\\"\\\"\\\"\\n    # TODO: Implement Function\\n    inputs = tf.placeholder(tf.int32, shape=[None, None], name='input')\\n    targets = tf.placeholder(tf.int32, shape=[None, None], name='targets')\\n    learning_rate = tf.placeholder(tf.float32, name='learning_rate')\\n    keep_prob = tf.placeholder(tf.float32, name='keep_prob')\\n    target_sequence_length = tf.placeholder(tf.int32, [None], name='target_sequence_length')\\n    max_target_sequence_length = tf.reduce_max(target_sequence_length)\\n    source_sequence_length = tf.placeholder(tf.int32, [None], name='source_sequence_length')\\n    \\n    return (inputs, targets, learning_rate, keep_prob, target_sequence_length, \\n            max_target_sequence_length, source_sequence_length)\\n\\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\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Import skymap and some of it's basic map classes\\nimport skymap\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe start by importing several classes from the skymap module and setting a few constants that we will use in this example.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"A single-process, univariate example\\nFirst we need a process model. In this case it will be a single stochastic process,\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprocess = proc.WienerProcess.create_from_cov(mean=3., cov=25.)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"And we finally have something that looks looks like the tropopause, with temperature increasing above at about the correct rate. Though the tropopause temperature is off by 15 degrees or so.\\nGreenhouse warming in the RCE model with ozone\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\noz_col2 = climlab.process_like( oz_col )\\n\\noz_col2.subprocess['LW'].absorptivity *= 1.2 \\n\\noz_col2.integrate_years(2.)\\n\\nfig = plt.figure( figsize=(10,8) )\\nax = fig.add_subplot(111)\\nax.plot( Tglobal + const.tempCtoK, np.log(level\\/const.ps), 'b-' )\\nax.plot( oz_col.Tatm, np.log( pozcol \\/ const.ps ), 'c-' )\\nax.plot( oz_col.Ts, 0, 'co', markersize=16 )\\nax.plot( oz_col2.Tatm, np.log( pozcol \\/ const.ps ), 'c--' )\\nax.plot( oz_col2.Ts, 0, 'co', markersize=16 )\\nax.invert_yaxis()\\nax.set_xlabel('Temperature (K)', fontsize=16)\\nax.set_ylabel('Pressure (hPa)', fontsize=16 )\\nax.set_yticks( np.log(level\\/const.ps) )\\nax.set_yticklabels( level.values )\\nax.set_title('Temperature profiles: observed (blue), RCE with ozone (cyan)', fontsize = 18)\\nax.grid()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# PROPERTY ID - DO NOT EDIT !  \\nDOC.set_id('cmip6.land.soil.hydrology.freezing.permafrost')  \\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\":\"\\n12.3. Permafrost\\nIs Required: TRUE&nbsp;&nbsp;&nbsp;&nbsp;Type: STRING&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 1.1\\nDescribe the treatment of permafrost, if any, within the land surface scheme\",\"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\\/archive\\/Trying geopandas to assign NERC regions.ipynb\\\".\\nThe first task is:\\nDrop plants without lat\\/lon data\\nFrom 2001-mid 2017, 9 facilities (out of 8,435) don't have valid lat\\/lon data. All of them are from 2010 or earlier. Drop these rows or the spatial join fails. The amount of generation from these plants is tiny - well under 0.05% in all years.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(len(facility_df['plant id'].unique()), 'total plants')\\nprint(len(facility_df.loc[facility_df['lat'].isnull(), 'plant id'].unique()),\\n      'plants without lat\\/lon')\\n\\nyears = facility_df.loc[facility_df['lat'].isnull(), 'year'].unique()\\nfor year in years:\\n    total_gen = facility_df.loc[facility_df['year'] == year, 'generation (MWh)'].sum()\\n    \\n    # Plant ids with no 'lat' in year\\n    no_loc_plants = facility_df.loc[(facility_df['lat'].isnull()) & \\n                                    (facility_df['year'] == year), 'plant id'].unique()\\n    \\n    no_loc_gen = facility_df.loc[(facility_df['year'] == year) &\\n                                 (facility_df['plant id'].isin(no_loc_plants)),\\n                                  'generation (MWh)'].sum()\\n    \\n    percent_dropped = no_loc_gen \\/ total_gen * 100\\n    \\n    print('In {}, {:.3f}% of generation is from plants without lat\\/lon'.format(year, percent_dropped))\\n\\nfacility_df.dropna(inplace=True, subset=['lat', 'lon'])\\n\\nfacility_df.columns\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Exploring_Domestic_Flights.ipynb\\\".\\nThe first task is:\\nThis notebook will be describing an analysis of US domestic flight data. We will first take a dive into a single year, 2008 and do some basic analysis. Then we may expand this into multiple years to try and see trends. Finally we will use a single year to build a predictive model to predict weather or not a flight will be delayed or not.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf_flights_2008 = pd.read_csv('\\/home\\/hakim\\/Documents\\/Airline_delays-\\/flight_data_historical\\/2008.csv')\\nprint(df_flights_2008.tail())\\n\\ndf_flights_2008.shape\\n\\ndf_flights_2008.isnull().sum(axis=0)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# take the first tweet of the list\\ntweet = tweet_list[2]\\n\\n# each tweet is a python dictionary\\ntype(tweet)\\n\\n# all the 'entries' of the dictionary\\ntweet.keys()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLet's look at the informations contained in a tweet\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"17-09-17-Python-for-Financial-Analysis-and-Algorithmic-Trading\\/.ipynb_checkpoints\\/2 - Numpy Exercises-checkpoint.ipynb\\\".\\nThe first task is:\\nUse NumPy to generate a random number between 0 and 1\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# CODE HERE\\nnp.random.randn(1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2. Uso de Pandas para descargar datos de precios de cierre\\nBajar datos en forma de función\\n\",\"targets\":\"def get_historical_closes(ticker, start_date, end_date):\\n    p = web.DataReader(ticker, \\\"yahoo\\\", start_date, end_date).sort_index('major_axis')\\n    d = p.to_frame()['Adj Close'].reset_index()\\n    d.rename(columns={'minor': 'Ticker', 'Adj Close': 'Close'}, inplace=True)\\n    pivoted = d.pivot(index='Date', columns='Ticker')\\n    pivoted.columns = pivoted.columns.droplevel(0)\\n    return pivoted\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Chapter2_MorePyMC\\/Ch2_MorePyMC_PyMC3.ipynb\\\".\\nThe first task is:\\nLater we will see how we use this to make predictions and test the appropriateness of our models.\\nExample: Bayesian A\\/B testing\\nA\\/B testing is a statistical design pattern for determining the difference of effectiveness between two different treatments. For example, a pharmaceutical company is interested in the effectiveness of drug A vs drug B. The company will test drug A on some fraction of their trials, and drug B on the other fraction (this fraction is often 1\\/2, but we will relax this assumption). After performing enough trials, the in-house statisticians sift through the data to determine which drug yielded better results. \\nSimilarly, front-end web developers are interested in which design of their website yields more sales or some other metric of interest. They will route some fraction of visitors to site A, and the other fraction to site B, and record if the visit yielded a sale or not. The data is recorded (in real-time), and analyzed afterwards. \\nOften, the post-experiment analysis is done using something called a hypothesis test like difference of means test or difference of proportions test. This involves often misunderstood quantities like a \\\"Z-score\\\" and even more confusing \\\"p-values\\\" (please don't ask). If you have taken a statistics course, you have probably been taught this technique (though not necessarily learned this technique). And if you were like me, you may have felt uncomfortable with their derivation -- good: the Bayesian approach to this problem is much more natural. \\nA Simple Case\\nAs this is a hacker book, we'll continue with the web-dev example. For the moment, we will focus on the analysis of site A only. Assume that there is some true $0 \\\\lt p_A \\\\lt 1$ probability that users who, upon shown site A, eventually purchase from the site. This is the true effectiveness of site A. Currently, this quantity is unknown to us. \\nSuppose site A was shown to $N$ people, and $n$ people purchased from the site. One might conclude hastily that $p_A = \\\\frac{n}{N}$. Unfortunately, the observed...\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport pymc3 as pm\\n\\n# The parameters are the bounds of the Uniform.\\nwith pm.Model() as model:\\n    p = pm.Uniform('p', lower=0, upper=1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# On définit une fonction de création de table\\ndef CreateTable(nom_bdd):\\n    QueryCurs.execute('''CREATE TABLE IF NOT EXISTS ''' + nom_bdd + '''\\n    (id INTEGER PRIMARY KEY, Name TEXT,City TEXT, Country TEXT, Price REAL)''')\\n\\n# On définit une fonction qui permet d'ajouter des observations dans la table    \\ndef AddEntry(nom_bdd, Nom,Ville,Pays,Prix):\\n    QueryCurs.execute('''INSERT INTO ''' + nom_bdd + ''' \\n    (Name,City,Country,Price) VALUES (?,?,?,?)''',(Nom,Ville,Pays,Prix))\\n    \\ndef AddEntries(nom_bdd, data):\\n    \\\"\\\"\\\" data : list with (Name,City,Country,Price) tuples to insert\\n    \\\"\\\"\\\"\\n    QueryCurs.executemany('''INSERT INTO ''' + nom_bdd + ''' \\n    (Name,City,Country,Price) VALUES (?,?,?,?)''',data)\\n    \\n    \\n### On va créer la table clients\\n\\nCreateTable('Clients')\\n\\nAddEntry('Clients','Toto','Munich','Germany',5.2)\\nAddEntries('Clients',\\n    [('Bill','Berlin','Germany',2.3),\\n    ('Tom','Paris','France',7.8),\\n    ('Marvin','Miami','USA',15.2),\\n    ('Anna','Paris','USA',7.8)])\\n\\n# on va \\\"commit\\\" c'est à dire qu'on va valider la transaction. \\n# > on va envoyer ses modifications locales vers le référentiel central - la base de données SQL\\n\\nCreateDataBase.commit()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLa méthode cursor() est un peu particulière : \\nIl s'agit d'une sorte de tampon mémoire intermédiaire, destiné à mémoriser temporairement les données en cours de traitement, ainsi que les opérations que vous effectuez sur elles, avant leur transfert définitif dans la base de données. Tant que la  méthode .commit() n'aura pas été appelée, aucun ordre ne sera appliqué à la base de données.\\n\\nA présent que nous sommes connectés à la base de données, on va créer une table qui contient plusieurs variables de format différents\\n- ID sera la clé primaire de la base\\n- Nom, Rue, Ville, Pays seront du text\\n- Prix sera un réel\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Compute the test statistic of the real data to verify that it works.\\n\",\"targets\":\"T_true = T(y)\\nprint(\\\"The test statistic of the real data is T =\\\", T_true)\",\"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_Mathematical_Groundwork\\/2_8_the_discrete_fourier_transform.ipynb\\\".\\nThe first task is:\\n2.8. The Discrete Fourier Transform (DFT) and the Fast Fourier Transform (FFT)<a id='math:sec:the_discrete_fourier_transform_and_the_fast_fourier_transform'><\\/a>\\nThe continuous version of the Fourier transform can only be computed when the integrals involved can be evaluated analytically, something which is not always possible in real life applications. This is true for a number of reasons, the most relevant of which are:\\n\\n\\nWe don't always have the parametrisation of the signal that we want to find the Fourier transform of.\\n\\n\\nSignals are measured and recorded at a finite number of points.\\n\\n\\nMeasured signals are contaminated by noise.\\n\\n\\nIn such cases the discrete equivalent of the Fourier transform, called the discrete Fourier transform (DFT), is very useful. In fact, where the scale of the problem necessitates using a computer to perform calculations, the Fourier transform can only be implemented as the discrete equivalent. There are some subtleties we should be aware of when implementing the DFT. These mainly arise because it is very difficult to capture the full information present in a continuous signal with a finite number of samples. In this chapter we review the DFT and extend some of the most useful identities derived in the previous sections to the case where we only have acces to a finite number of samples. The subtleties that arise due to limited sampling will be discussed in the next section.\\n2.8.1 The discrete time Fourier transform (DTFT): definition<a id='math:sec:the_discrete_time_fourier_transform_definition'><\\/a>\\nWe start by introducing the discrete time Fourier transform (DTFT). The DTFT of a set $\\\\left{y_n \\\\in \\\\mathbb{C}\\\\right}_{n ~ \\\\in ~ \\\\mathbb{Z}}$ results in a Fourier series (see $\\\\S$ 2.3 &#10142;) of the form\\n<a id='math:eq:8_001'><\\/a><!--\\\\label{math:eq:8_001}-->$$\\nY_{2\\\\pi}(\\\\omega) = \\\\sum_{n\\\\,=\\\\,-\\\\infty}^{\\\\infty} y_n\\\\,e^{-\\\\imath \\\\omega n} \\\\quad \\\\mbox{where} \\\\quad n \\\\in \\\\mathbb{Z}.\\n$$\\nThe resulting function is a periodic function of the frequency variable $\\\\omega$. In the above...\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef loop_DFT(x):\\n    \\\"\\\"\\\"\\n    Implementing the DFT in a double loop\\n    Input: x = the vector we want to find the DFT of\\n    \\\"\\\"\\\"\\n    #Get the length of the vector (will only work for 1D arrays)\\n    N = x.size\\n    #Create vector to store result in\\n    X = np.zeros(N,dtype=complex)\\n    for k in range(N):\\n        for n in range(N):\\n            X[k] += np.exp(-1j*2.0*np.pi*k*n\\/N)*x[n]\\n    return X\",\"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\\/EIA Bulk Download - extract facility generation.ipynb\\\".\\nThe first task is:\\nLoad emission factors\\nThese are mostly EIA emission factors\\nCan you write Python code for it?\\n\",\"targets\":\"\\npath = os.path.join('Clean data', 'Final emission factors.csv')\\nef = pd.read_csv(path, index_col=0)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# append \\n\\nstaff.append('Finance')\\nprint(staff)\\n\\n# pop away the information about his salary\\n\\nandys_salary = staff.pop(2)\\nprint(andys_salary)\\nprint(staff)\\n\\n# oops, made a mistake, I want to reinsert information about his salary\\n\\nstaff.insert(3, andys_salary)\\nprint(staff)\\n\\ncontacts = [99993535, \\\"andy@company.com\\\"]\\n\\nstaff = staff+contacts # reassignment of the concatenated list back to staff\\nprint(staff)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n4.3 List methods\\nRight now, let us look at four very useful list methods. Methods are basically operations which modify lists. These are: \\n\\npop which allows us to remove an item in a list. \\n\\nSo for example if $x_0, x_1, \\\\ldots, x_n$ are items in a list, calling my_list.pop(r) will modify the list so that it contains only $$x_0, \\\\ldots, x_{r-1}, x_{r+1},\\\\ldots, x_n$$ while returning the element $x_r$. \\n\\nappend which adds items to the end of the list. \\n\\nLet's say $x_{n+1}$ is the new object you wish to append to the end of the list. Calling the method my_list.append(x_n+1) will modify the list inplace so that the list will now contain $$x_0, \\\\ldots, x_n, x_{n+1}$$ Note that append does not return any output! \\n\\ninsert which as the name suggests, allows us to add items to a list in a particular index location\\n\\nWhen using this, type my_list.insert(r, x_{n+1}) with  the second argument to the method the object you wish to insert and r the position (still 0 indexed) where this object ought to go in that list. This method modifies the list inplace and does not return any output. After calling the insert method, the list now contains $$x_0,\\\\ldots, x_{r-1}, x_{n+1}, x_{r}, \\\\ldots, x_n$$ This means that my_list[r] = $x_{n+1}$ while my_list[r+1] = $x_{r}$\\n\\n+ is used to concatenate two lists. If you have two lists and want to join them together producing a union of two (or more lists), use this binary operator. \\n\\nThis works by returning a union of two lists. So $$[ x_1,\\\\ldots, x_n] + [y_1,\\\\ldots, y_m]$$ is the list containing $$ x_1,\\\\ldots, x_n,y_1, \\\\ldots, y_m$$ This change is not permanent unless you assign the result of the operation to another variable.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Solution\\n\\npsi3=sqrt(0.8)*tensor(H,H) + sqrt(0.2)*tensor(V,V)\\n\\nout = []\\nfor r in rads:\\n    out.append(expect(tensor(P(-r),P(r)),psi3))\\n\\nplt.plot(angles,out,\\\".\\\") # plot in units of pi\\n\\n# Solution\\nout = []\\nfor r in rads:\\n    out.append(expect(tensor(P(r),P(deg2rad(55))),psi3) \\/ expect(tensor(P(r),qeye(2)),psi3))\\n\\nplt.plot(angles,out,\\\".\\\")\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nChallenge:\\nIf we change the state to $\\\\big|\\\\psi\\\\big\\\\rangle = \\\\sqrt{0.8} \\\\big|H,H\\\\big\\\\rangle + \\\\sqrt{0.2} \\\\big|V,V\\\\big\\\\rangle$, the two angles that work for this state.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"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:\\nAs well as just a simple line plot:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nair_quality.O3.plot(grid=True, figsize=(12, 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 \\\"2. Recommender system.ipynb\\\".\\nThe first task is:\\nCrowd Funding Recommender system\\nIdea\\n\\nFor new crowd funding projects, there are no such classificable factors with old projects (I suppose category is not a key factor)\\nUsers are only interested in a project itself (Funding target money, duration, etc are non of their business)\\nDoc2vec is a quite logical method to classify documents\\nClassifying descriptions of projects by using Doc2vec -> Recommending 10 nearest projects with a project users clicked or supported\\n\\nOutline\\n\\nTokenizing description\\nRun Doc2vec\\nCalculate distance of each project combinations\\nRecommend\\nCan you write Python code for it?\\n\",\"targets\":\"\\ncf_df = pd.read_excel('cf_description.xlsx')\",\"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-18-17_application_real_data.ipynb\\\".\\nThe first task is:\\nAs you can notice, the punctuation doesn't the word count because the symbols are attached to the previous word. However, the em dash '—' symbol links two words and that will affect the count, so let's replace them with a space so when we split by spaces it will do what we want.\\nIf you don't have the em dash symbol in your keyword you can generate it by doing (Ctrl+Shift+u)+2014.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#We want to keep first_paragraph without changes, so we create a copy and work with that.\\nrevised_paragraph = first_paragraph \\n\\nfor element in revised_paragraph:\\n    if element == '—':\\n        revised_paragraph = revised_paragraph.replace(element, ' ')\\n\\nprint(revised_paragraph)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"As we can see there is 2.3 times as many sample for the control group. And because of this, we can be picky and select only a part of the samples in the control group that correspond to the samples in the treatment group. To do so, we will match two samples together from each groups corresponding to their propensity score and then only keep and compare the samples matched.\\n1.3) A propensity score model\\nLet's calculate the propensity score\\n\",\"targets\":\"from sklearn.linear_model import LogisticRegression\\n\\nlr = LogisticRegression()\\n#Select features, that is drop id and treat columns\\nselectedFeatures = lalonde_data.drop(['id','treat'], axis=1)\\n#Fit the model\\nlr.fit(selectedFeatures, lalonde_data['treat']);\\n\\n#Calculate the propensity scores\\npropensity_scores = lr.predict_proba(selectedFeatures)\\n\\n#Only keep the probability of receiving the treatment and store it inside the dataframe\\nlalonde_data['propensity score'] = [x[1] for x in propensity_scores]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# separate the calls data for plotting\\n\\nchurnDFs = churnDFs[['Account Length','Day Calls','Eve Calls','CustServ Calls','Churn']]\\n\\n# Create scatter plot matrix of call data\\nsplom = ff.create_scatterplotmatrix(churnDFs, diag='histogram', index='Churn',  \\n                                  colormap= dict(\\n                                      Churn = '#9CBEF1',\\n                                      Retain = '#04367F'\\n                                      ),\\n                                  colormap_type='cat',\\n                                  height=560, width=650,\\n                                  size=4, marker=dict(symbol='circle'))\\npy.iplot(splom)\\n\\n%%capture\\n\\n#h2o.connect(ip=\\\"35.225.239.147\\\")\\nh2o.init(nthreads=1, max_mem_size=\\\"768m\\\")\\n\\n%%capture\\n\\n# Split data into training and testing frames\\n\\nfrom sklearn import cross_validation\\nfrom sklearn.model_selection import train_test_split\\n\\ntraining, testing = train_test_split(churnDF, train_size=0.8, stratify=churnDF[\\\"Churn\\\"], random_state=9)\\ntrain = h2o.H2OFrame(python_obj=training).drop(\\\"State\\\")\\ntest = h2o.H2OFrame(python_obj=testing).drop(\\\"State\\\")\\n\\n# Set predictor and response variables\\ny = \\\"Churn\\\"\\nx = train.columns\\nx.remove(y)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nScatterplot Matrix\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Use this token pattern to keep single-letter words\\nvectorizer = CountVectorizer(token_pattern=r'\\\\b\\\\w+\\\\b')\\n# First, learn vocabulary from the training data and assign columns to words\\n# Then convert the training data into a sparse matrix\\ntrain_matrix = vectorizer.fit_transform(train_data['review_clean'])\\n# Second, convert the test data into a sparse matrix, using the same word-column mapping\\ntest_matrix = vectorizer.transform(test_data['review_clean'])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nBuild the word count vector for each review\\nWe will now compute the word count for each word that appears in the reviews. A vector consisting of word counts is often referred to as bag-of-word features. Since most words occur in only a few reviews, word count vectors are sparse. For this reason, scikit-learn and many other tools use sparse matrices to store a collection of word count vectors. Refer to appropriate manuals to produce sparse word count vectors. General steps for extracting word count vectors are as follows:\\n\\nLearn a vocabulary (set of all words) from the training data. Only the words that show up in the training data will be considered for feature extraction.\\nCompute the occurrences of the words in each review and collect them into a row vector.\\nBuild a sparse matrix where each row is the word count vector for the corresponding review. Call this matrix train_matrix.\\nUsing the same mapping between words and columns, convert the test data into a sparse matrix test_matrix.\\n\\nThe following cell uses CountVectorizer in scikit-learn. Notice the token_pattern argument in the constructor.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"And you can use vector functions to get the magnitude and angle.\\n\",\"targets\":\"vector_mag(V2), vector_angle(V2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%bash\\n# after fixing `.at` redundancy - calling it in each apply call\\n# git checkout 4c978aff110001efdc917ed60cb611139e1b54c9 -b remove-getitem-redundancy\\n# time gypsy simulate ..\\/private-data\\/prepped_random_sample_300.csv --output-dir tmp\\n# rm -rfd tmp\\n\\n# real\\t5m36.407s\\n# user\\t5m25.740s\\n# sys\\t0m2.140s\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nHm, this actually got worse, although it is a small sample......... if anything i suspect its because we're calling row.at[] instead of assigning the variable outside the loop. It's ok as the code has less reptition, it's a good tradeoff.\",\"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-Project-Fletcher\\/Phases\\/Phase_3\\/Phase_3_Notebook.ipynb\\\".\\nThe first task is:\\nStep 1: Obtain my tweets!\\nI will obtain my entire tweet history! Note: For 2nd degree potential followers, I only extract 200 of their most recent tweets!\\nCan you write Python code for it?\\n\",\"targets\":\"\\ngabr_tweets = extract_users_tweets(\\\"gabr_ibrahim\\\", 2000)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# PROMPT 19 TODO Write Test\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nStep 3c: printBeers() Test\\nUse the beers and calories from PROMPT6\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<h3>2. <a href=\\\"http:\\/\\/www.shogun-toolbox.org\\/doc\\/en\\/latest\\/classshogun_1_1LinearSolver.html\\\">Linear Solvers<\\/a><\\/h3>\\n<p> Conjugate Gradient based iterative solvers, that construct the Krylov subspace in their iteration by computing matrix-vector products are most useful for solving sparse linear systems. Here is an overview of CG based solvers that are currently available in Shogun.<\\/p>\\n<h4> <a href=\\\"http:\\/\\/www.shogun-toolbox.org\\/doc\\/en\\/latest\\/classshogun_1_1CConjugateGradientSolver.html\\\">Conjugate Gradient Solver<\\/a><\\/h4>\\nThis solver solves for system $\\\\mathbf{Qx}=\\\\mathbf{y}$, where $\\\\mathbf{Q}$ is real-valued spd linear operator (e.g. dense\\/sparse matrix operator), and $\\\\mathbf{y}$ is real vector.\\n\",\"targets\":\"from scipy.sparse import csc_matrix\\nfrom scipy.sparse import identity\\n\\n# creating a random spd matrix\\ndim = 5\\nnp.random.seed(10)\\nm = csc_matrix(np.random.randn(dim, dim))\\na = m.transpose() * m + csc_matrix(np.identity(dim))\\nQ = sg.RealSparseMatrixOperator(a)\\n\\n# creating a random vector\\ny = np.array(np.random.randn(dim))\\n\\n# solve the system Qx=y\\n# the argument is set as True to gather convergence statistics (default is False)\\ncg = sg.ConjugateGradientSolver(True)\\ncg.set_iteration_limit(20)\\nx = cg.solve(Q,y)\\n\\nprint('x:',x)\\n\\n# verifying the result\\nprint('y:', y)\\nprint('Qx:', Q.apply(x))\\n\\nresiduals = cg.get_residuals()\\nplt.plot(residuals)\\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 \\\"Chapman\\/Ch6-Example_6-05d_gen.ipynb\\\".\\nThe first task is:\\nFirst, initialize the values needed in this program.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nr1 =  0.641                # Stator resistance\\nx1 =  1.106                # Stator reactance\\nr2 =  0.332                # Rotor resistance\\nx2 =  0.464                # Rotor reactance\\nxm = 26.3                  # Magnetization branch reactance\\nv_phase =  460 \\/ sqrt(3)   # Phase voltage\\nn_sync  = 1800             # Synchronous speed (r\\/min)\\nw_sync  = n_sync * 2*pi\\/60 # Synchronous speed (rad\\/s)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2. Elemental Mass and Stiffness matrices\\nThe mass and the stiffness matrix are calculated prior time extrapolation, so they are pre-calculated and stored at the beginning of the code. \\nThe integrals defined in the mass and stiffness matrices are computed using a numerical quadrature, in this cases the GLL quadrature that uses the GLL points and their corresponding weights to approximate the integrals. Hence,\\n\\\\begin{equation}\\nM_{ij}^k=\\\\int_{-1}^1 \\\\ell_i^k(\\\\xi)  \\\\ell_j^k(\\\\xi) \\\\ J \\\\ d\\\\xi = \\\\sum_{m=1}^{N_p} w_m \\\\ \\\\ell_i^k (x_m)  \\\\ell_j^k(x_m)\\\\ J =\\\\sum_{m=1}^{N_p} w_m \\\\delta_{im}\\\\ \\\\delta_{jm} \\\\ J= \\\\begin{cases} w_i \\\\ J \\\\ \\\\ \\\\text{ if } i=j \\\\ 0 \\\\ \\\\ \\\\ \\\\ \\\\ \\\\ \\\\ \\\\text{   if } i \\\\neq j\\\\end{cases}\\n\\\\end{equation}\\nthat is a diagonal mass matrix!. Subsequently, the stiffness matrices is given as \\n\\\\begin{equation} \\nK_{i,j}= \\\\int_{-1}^1 \\\\ell_i^k(\\\\xi) \\\\cdot \\\\partial x  \\\\ell_j^k(\\\\xi) \\\\ d\\\\xi= \\\\sum{m=1}^{N_p} w_m \\\\ \\\\ell_i^k(x_m)\\\\cdot \\\\partial_x \\\\ell_j^k(x_m)= \\\\sum_{m=1}^{N_p} w_m \\\\delta_{im}\\\\cdot \\\\partial_x\\\\ell_j^k(x_m)= w_i \\\\cdot \\\\partial_x \\\\ell_j^k(x_i) \\n\\\\end{equation}\\nThe Lagrange polynomials and their properties have been already used, they determine the integration weights $w_i$ that are returned by the python method \\\"gll\\\". Additionally, the fist derivatives of such basis, $\\\\partial_x \\\\ell_j^k(x_i)$, are needed, the python method \\\"Lagrange1st\\\" returns them.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Initialization of system matrices\\n# -----------------------------------------------------------------\\n# Elemental Mass matrix\\nM = np.zeros((N+1, N+1))\\nfor i in range(0, N+1):\\n    M[i, i] = w[i] * J\\n\\n# Inverse matrix of M (M is diagonal!)\\nMinv = np.identity(N+1)\\nfor i in range(0, N+1):\\n    Minv[i,i] = 1. \\/ M[i,i]\\n\\n# Elemental Stiffness Matrix\\nK = np.zeros((N+1, N+1))\\nfor i in range(0, N+1):\\n    for j in range(0, N+1):\\n            K[i,j] = w[j] * l1d[i,j] # NxN matrix for every element\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# This Colab requires TF 2.5.\\n!pip install -U \\\"tensorflow>=2.5\\\"\\n\\nimport os\\nimport pathlib\\n\\nimport matplotlib\\nimport matplotlib.pyplot as plt\\n\\nimport io\\nimport scipy.misc\\nimport numpy as np\\nfrom six import BytesIO\\nfrom PIL import Image, ImageDraw, ImageFont\\nfrom six.moves.urllib.request import urlopen\\n\\nimport tensorflow as tf\\nimport tensorflow_hub as hub\\n\\ntf.get_logger().setLevel('ERROR')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<table class=\\\"tfo-notebook-buttons\\\" align=\\\"left\\\">\\n  <td>     <a target=\\\"_blank\\\" href=\\\"https:\\/\\/www.tensorflow.org\\/hub\\/tutorials\\/tf2_object_detection\\\"><img src=\\\"https:\\/\\/www.tensorflow.org\\/images\\/tf_logo_32px.png\\\">TensorFlow.org で表示<\\/a>   <\\/td>\\n  <td>     <a target=\\\"_blank\\\" href=\\\"https:\\/\\/colab.research.google.com\\/github\\/tensorflow\\/docs-l10n\\/blob\\/master\\/site\\/ja\\/hub\\/tutorials\\/tf2_object_detection.ipynb\\\"><img src=\\\"https:\\/\\/www.tensorflow.org\\/images\\/colab_logo_32px.png\\\">Google Colab で実行<\\/a>   <\\/td>\\n  <td>     <a target=\\\"_blank\\\" href=\\\"https:\\/\\/github.com\\/tensorflow\\/docs-l10n\\/blob\\/master\\/site\\/ja\\/hub\\/tutorials\\/tf2_object_detection.ipynb\\\"><img src=\\\"https:\\/\\/www.tensorflow.org\\/images\\/GitHub-Mark-32px.png\\\">    GitHub でソースを表示<\\/a> <\\/td>\\n  <td>     <a href=\\\"https:\\/\\/storage.googleapis.com\\/tensorflow_docs\\/docs-l10n\\/site\\/ja\\/hub\\/tutorials\\/tf2_object_detection.ipynb\\\"><img src=\\\"https:\\/\\/www.tensorflow.org\\/images\\/download_logo_32px.png\\\">ノートブックをダウンロード<\\/a>   <\\/td>\\n  <td>     <a href=\\\"https:\\/\\/tfhub.dev\\/tensorflow\\/collections\\/object_detection\\/1\\\"><img src=\\\"https:\\/\\/www.tensorflow.org\\/images\\/hub_logo_32px.png\\\">TF Hub モデルを参照<\\/a>   <\\/td>\\n<\\/table>\\n\\nTensorFlow Hub オブジェクト検出 Colab\\nTensorFlow Hub オブジェクト検出 Colab へようこそ！このノートブックでは、「すぐに使える」画像用オブジェクト検出モデルを実行する手順を説明します。\\nその他のモデル\\nこのコレクションには、COCO 2017 データセットでトレーニングされた TF 2 オブジェクト検出モデルが含まれています。ここから、現在 tfhub.dev がホストしているすべてのオブジェクト検出モデルを見つけることができます。\\nインポートとセットアップ\\n基本のインポートから始めます。\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Task 1\\nembed = ...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<h2>TensorFlow Hub Concepts<\\/h2>\\n\\nTensorFlow Hub is a library for the publication, discovery, and consumption of reusable parts of machine learning models. A module is a self-contained piece of a TensorFlow graph, along with its weights and assets, that can be reused across different tasks in a process known as transfer learning, which we covered as part of the course on Image Models.\\nTo download and use a module, it's as easy as:\\nHowever, because modules are self-contained parts of a TensorFlow graph, in order to actually collect values from a module, you'll need to evaluate it in the context of a session.\\nFirst, let's explore what hub modules there are. Go to the documentation page and explore a bit.\\nNote that TensorFlow Hub has modules for Images, Text, and Other. In this case, we're interested in a Text module, so navigate to the Text section.\\nWithin the Text section, there are a number of modules. If you click on a link, you'll be taken to a page that describes the module and links to the original paper where the model was proposed. Click on a model in the Word2Vec section of the page.\\nNote the details section, which describes what the module expects as input, how it preprocesses data, what it does when it encounters a word it hasn't seen before (OOV means \\\"out of vocabulary\\\") and in this case, how word embeddings can be composed to form sentence embeddings.\\nFinally, note the URL of the page. This is the URL you can copy to instantiate your module.\\n<h2>Task 1: Create an embedding using the NNLM model<\\/h2>\\n\\nTo complete this task:\\n<ol>\\n    <li>Find the module URL for the NNLM 50 dimensional English model<\\/li>\\n    <li>Use it to instantiate a module as 'embed'<\\/li>\\n    <li>Print the embedded representation of \\\"cat\\\"<\\/li>\\n<\\/ol>\\n\\nNOTE: downloading hub modules requires downloading a lot of data. Instantiating the module will take a few minutes.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Introduction to Data Science in Python\\/Week 2\\/.ipynb_checkpoints\\/Assignment2-checkpoint.ipynb\\\".\\nThe first task is:\\nQuestion 1\\nWhich country has won the most gold medals in summer games?\\nThis function should return a single string value.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef answer_one():\\n    df_copy = df.copy()\\n    df_copy.index.names = [\\\"Country\\\"]\\n    df_copy = df_copy.reset_index()\\n    df_copy = df_copy.set_index(\\\"Gold\\\")\\n    df_copy = df_copy.sort_index()\\n    return df_copy.iloc[len(df_copy)-1][\\\"Country\\\"]\\nanswer_one()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"After the download completes, the blinker logic starts to run inside the FPGA,\\nconverting the 12 MHz clock into a 3 Hz blinking of the LED.\\n\\nLooks like that's about 3 Hz to me!\\n<a name=\\\"No_Jupyter\\\"><\\/a>But I Don't Like Jupyter!\\nOK, maybe you're one of those guys, so here's how to do it all from the command line.\\nFirst, create a file called blinker.py using your favorite text editor (which is probably vi or Emacs, I guess).\\nThe file just contains the same MyHDL code I showed above.\\nHere's my version of it:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint(open('blinker.py').read())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"After 60 minutes, you might see that the number of bike at Olin is negative.  We'll fix that problem in the next notebook.\\nBut first, we want to plot the results.\\nTimeSeries\\nmodsim.py provides an object called a TimeSeries that can contain a sequence of values changing over time.\\nWe can create a new, empty TimeSeries like this:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nresults = TimeSeries()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"MNIST\\/0410 -  MNIST Project 6 - The ROC Curve\\/MNIST.ipynb\\\".\\nThe first task is:\\nNote the result here may vary from the video as the results from the confusion matrix are different each time you run it.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprecision_score(y_train_0, y_train_pred) # 5618 \\/ (574 + 5618)\\n\\n5618 \\/ (574 + 5618)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"6) Create A New Model\\nCreate a new model called second_fashion_model in the cell below.  Make some changes so it is different than fashion_model that you've trained above. The change could be using a different number of layers, different number of convolutions in the layers, etc.\\nDefine the model, compile it and fit it in the cell below.  See how its validation score compares to that of the original model.\\n\",\"targets\":\"# Your code below\\n____\\n\\n\\n# Don't remove this line (ensures comptibility with tensorflow 2.0)\\nsecond_fashion_model.history.history['val_acc'] = second_fashion_model.history.history['val_accuracy']\\n# Check your answer\\nq_6.check()\\n\\n#_COMMENT_IF(PROD)_\\nq_6.solution()\\n\\n#%%RM_IF(PROD)%%\\nfrom tensorflow import keras\\nfrom tensorflow.keras.models import Sequential\\nfrom tensorflow.keras.layers import Dense, Flatten, Conv2D\\n\\nfashion_model = Sequential()\\nq_1.assert_check_passed()\\n\\nfashion_model.add(Conv2D(12,\\n                         activation='relu',\\n                         kernel_size=3,\\n                         input_shape = (img_rows, img_cols, 1)))\\nq_2.assert_check_passed()\\n\\nfashion_model.add(Conv2D(20, activation='relu', kernel_size=3))\\nfashion_model.add(Conv2D(20, activation='relu', kernel_size=3))\\nfashion_model.add(Flatten())\\nfashion_model.add(Dense(100, activation='relu'))\\nfashion_model.add(Dense(10, activation='softmax'))\\n\\nq_3.assert_check_passed()\\n\\nfashion_model.compile(loss='categorical_crossentropy',\\n                      optimizer='adam',\\n                      metrics=['accuracy'])\\n\\nq_4.assert_check_passed()\\n\\n# 1 epoch and high val_split to speed up testing\\nfashion_model.fit(x, y, batch_size=100, epochs=1, validation_split=0.5)\\n\\nq_5.assert_check_passed()\\n\\nsecond_fashion_model = Sequential()\\nsecond_fashion_model.add(Conv2D(12,\\n                         activation='relu',\\n                         kernel_size=3,\\n                         input_shape = (img_rows, img_cols, 1)))\\n# Changed kernel sizes to be 2\\nsecond_fashion_model.add(Conv2D(20, activation='relu', kernel_size=2))\\nsecond_fashion_model.add(Conv2D(20, activation='relu', kernel_size=2))\\n# added an addition Conv2D layer\\nsecond_fashion_model.add(Conv2D(20, activation='relu', kernel_size=2))\\nsecond_fashion_model.add(Flatten())\\nsecond_fashion_model.add(Dense(100, activation='relu'))\\n# It is important not to change the last layer. First argument matches number of classes. Softmax guarantees we get reasonable...\",\"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\\/examples\\/rossiter_mclaughlin.ipynb\\\".\\nThe first task is:\\nTo visualize what is happening, we can plot the radial velocities of each surface element in the mesh at one of these times.\\nHere just plot on the mesh@model parameterset - the mesh will automatically get coordinates from mesh01 and then we point to rvs@numericalrvs for the facecolors.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfig = plt.figure(figsize=(12,12))\\naxs, artists = b['mesh@model'].plot(time=0.03, facecolor='rvs@numericalrvs', edgecolor=None)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"6.\\nA veces, es necesario en nuestro problema, tener que eliminar los elementos repetidos de una lista, dejando aquellos que solo aparezcan una sola vez. Es muy común, que muchos usuarios llamen a la función set para esta tarea, haciendo de la lista un conjunto sin elementos repetidos, ordenándolos y luego, el resultado de esto, volverlo a convertir en una lista. Esto, puede no estar mal del todo, pero puede ser que en el caso peor, puede que estemos haciendo un gasto inútil de memoria, tiempo y cálculos, para que, en el caso de que no haya elementos repetidos, sólo obtengamos una lista ordenada.\\nEs por ello, por lo que existe otra forma de hacerlo. Utilizando lo ya visto, obtén una lista sin elementos repetidos que mantengan el orden de la lista original. Para hacerlo aún más divertido, no uses más de 4 líneas.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\na = [1,1,1,2,5,3,4,8,5,8]\\nb = []\\nlist(filter(lambda x: b.append(x) if not x in b else False, a))\\nprint(\\\"Lista original:\\\\t\\\\t\\\", a)\\nprint(\\\"Lista sin repetidos:\\\\t\\\", b)\",\"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\\/1-Basic skills\\/jieba中文处理.ipynb\\\".\\nThe first task is:\\n关键词提取¶\\n基于 TF-IDF 算法的关键词抽取\\nimport jieba.analyse\\n - jieba.analyse.extract_tags(sentence, topK=20, withWeight=False, allowPOS=())\\n   - sentence 为待提取的文本\\n   - topK 为返回几个 TF\\/IDF 权重最大的关键词，默认值为 20\\n   - withWeight 为是否一并返回关键词权重值，默认值为 False\\n   - allowPOS 仅包括指定词性的词，默认值为空，即不筛选\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport jieba.analyse as analyse\\nlines = open('人工智能火了-人类有些尴尬了.txt').read()\\nprint(type(lines))\\nseg_list = analyse.extract_tags(lines,topK=15,withWeight=False,allowPOS=())\\n#print(seg_list)\\ntext = \\\" \\\".join(seg_list)\\nprint(text)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Annotating the curve\\nWrapping your data (xs and ys) here as a HoloViews element is sufficient to make it visualizable, but there are many other aspects of the data that we can capture to convey more about its meaning to HoloViews. For instance, we might want to specify what the x-axis and y-axis actually correspond to, in the real world. Perhaps this parabola is the trajectory of a ball thrown into the air, in which case we could declare the object as:\\n\",\"targets\":\"trajectory = hv.Curve((xs,ys), kdims=['distance'], vdims=['height'])\\ntrajectory\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create a Simulation object by running tardis\\nfrom tardis import run_tardis\\nsim = run_tardis('tardis_example.yml')\\n\\n# Now use it to create a shell info widget\\nshell_info = tw.shell_info_from_simulation(sim)\\n\\n# Call display method of shell_info\\nshell_info.display()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nShell Info\\nThis widget allows you to get fractional abundances of each shell - all the way from elements to ions to levels - by just clicking on the rows you want to explore!\\nThere are two ways in which you can generate the widget:\\nUsing Simulation object\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%matplotlib inline\\nimport matplotlib.pyplot as plt\\ntemperatures = [4.4,5.1,6.1,6.2,6.1,6.1,5.7,5.2,4.7,4.1,3.9,3.5]\\ns7 = pd.Series(temperatures, name=\\\"Temperature\\\")\\ns7.plot()\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPlotting a Series\\nPandas makes it easy to plot Series data using matplotlib (for more details on matplotlib, check out the matplotlib tutorial). Just import matplotlib and call the plot() method:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Blocking\\nWe can block a curve. Let's look at a small segment:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsegment = gr.to_basis(start=600, stop=680)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Subtract two matrices\\nnp.subtract(matrix_a, matrix_b)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSubtract Matrices\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<p style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\n    הפונקציה הזו יכולה לסייע לנו להגיע לתובנות בנוגע לדרך שבה פייתון עובדת בכל מיני מצבים.<br>\\n    קשה להבין, לדוגמה, מה קורה בקוד הבא:\\n<\\/p>\\n\",\"targets\":\"collections_of_numbers = [[0, 0, 0]] * 3  # ניצור 3 רשימות של 3 איברים בכל אחת\\nprint(collections_of_numbers)\\ncollections_of_numbers[0].append(100)  # נוסיף את האיבר 100 לרשימה הראשונה בלבד\\nprint(collections_of_numbers)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"A variety of factors seem to play a part in the baby's weight.  Male babies are heavier on average than female babies. Teenaged and older moms tend to have lower-weight babies.  Twins, triplets, etc. are lower weight than single births.  Preemies weigh in lower as do babies born to single moms. In addition, it is important to check whether you have enough data (number of babies) for each input value. Otherwise, the model prediction against input values that doesn't have enough data may not be reliable.\\n<p>\\nIn the rest of this notebook, we will use machine learning to combine all of these factors to come up with a prediction of a baby's weight.\\n\\n<h2> Create ML dataset using Dataflow <\\/h2>\\n<p>\\nWe can use Cloud Dataflow to read in the BigQuery data and write it out as CSV files. \\n\\nInstead of using Beam\\/Dataflow, I had three other options:\\n<ol>\\n<li> Use Cloud Dataprep to visually author a Dataflow pipeline. Cloud Dataprep also allows me to explore the data, so we could have avoided much of the handcoding of Python\\/Seaborn calls above as well!\\n<li> Read from BigQuery directly using TensorFlow. \\n<li> Use the BigQuery console (http:\\/\\/bigquery.cloud.google.com) to run a Query and save the result as a CSV file. For larger datasets, you may have to select the option to \\\"allow large results\\\" and save the result into a CSV file on Google Cloud Storage.\\n<\\/ol>\\n<p>\\nHowever, in this case, I want to do some preprocessing, modifying data so that we can simulate what is known if no ultrasound has been performed. If I didn't need preprocessing, I could have used the web console. Also, I prefer to script it out rather than run queries on the user interface, so I am using Cloud Dataflow for the preprocessing.\\n<p>\\nNote that I have set in_test_mode=True in the following code -- this will run the code locally on a small subset of the data -- the full results were copied into your bucket using the following code (in the previous cell):\\n<pre>\\ngsutil -m cp -R gs:\\/\\/cloud-training-demos\\/babyweight gs:\\/\\/${BUCKET}\\n<\\/pre>\\nIf you are running...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport apache_beam as beam\\nimport datetime\\n\\ndef to_csv(rowdict):\\n    # pull columns from BQ and create a line\\n    import hashlib\\n    import copy\\n    CSV_COLUMNS = 'weight_pounds,is_male,mother_age,plurality,gestation_weeks'.split(',')\\n    \\n    # create synthetic data where we assume that no ultrasound has been performed\\n    # and so we don't know sex of the baby. Let's assume that we can tell the difference\\n    # between single and multiple, but that the errors rates in determining exact number\\n    # is difficult in the absence of an ultrasound.\\n    no_ultrasound = copy.deepcopy(rowdict)\\n    w_ultrasound = copy.deepcopy(rowdict)\\n\\n    no_ultrasound['is_male'] = 'Unknown'\\n    if rowdict['plurality'] > 1:\\n      no_ultrasound['plurality'] = 'Multiple(2+)'\\n    else:\\n      no_ultrasound['plurality'] = 'Single(1)'\\n      \\n    # Change the plurality column to strings\\n    w_ultrasound['plurality'] = ['Single(1)', 'Twins(2)', 'Triplets(3)', 'Quadruplets(4)', 'Quintuplets(5)'][rowdict['plurality']-1]\\n    \\n    # Write out two rows for each input row, one with ultrasound and one without\\n    for result in [no_ultrasound, w_ultrasound]:\\n      data = ','.join([str(result[k]) if k in result else 'None' for k in CSV_COLUMNS])\\n      key = hashlib.sha224(data.encode('utf-8')).hexdigest()  # hash the columns to form a key\\n      yield str('{},{}'.format(data, key))\\n  \\ndef preprocess(in_test_mode):\\n    job_name = 'preprocess-babyweight-features' + '-' + datetime.datetime.now().strftime('%y%m%d-%H%M%S')\\n    \\n    if in_test_mode:\\n        print ('Launching local job ... hang on')\\n        OUTPUT_DIR = '.\\/preproc'\\n    else:\\n        print ('Launching Dataflow job {} ... hang on'.format(job_name))\\n        OUTPUT_DIR = 'gs:\\/\\/{0}\\/babyweight\\/preproc\\/'.format(BUCKET)\\n    \\n    options = {\\n        'staging_location': os.path.join(OUTPUT_DIR, 'tmp', 'staging'),\\n        'temp_location': os.path.join(OUTPUT_DIR, 'tmp'),\\n        'job_name': job_name,\\n        'project': PROJECT,\\n        'teardown_policy': 'TEARDOWN_ALWAYS',\\n       ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Assignments\\/ASSIGNMENT-1.ipynb\\\".\\nThe first task is:\\nHelp the cashier\\nCan you use the modulus operator you just learned about to solve the following task? Imagine you want to help cashiers to return the change in a convenient way. This means you do not want to return hands full of small coins, but rather use bills and as few coins as possible. \\nWrite code  that classifies a given amount of money into smaller monetary units. Given a specific amout of dollars, your program should report the maximum number of dollar bills,  quarters, dimes, nickels, and pennies. \\nSet the amount variable to 11.67. You code should output a report listing the monetary equivalent in dollars, quarters, dimes, nickels, and pennies (one quarter is equivalent to 25 cents; one dime to 10 cents; one nickle to 5 cents and a pennie to 1 cent). Your program should report the maximum number of dollars, then the number of quarters, dimes, nickels, and pennies, in this order, to result in the minimum number of coins. Here are the steps in developing the program:\\n\\nConvert the amount (11.67) into cents (1167).\\nFirst get the amount of cents that you would get after subtracting the maximum amount of dollars (100 cents) using the modulus operator (67 cents).\\nThen subtract the remainder (67 cents) from the total amount of cents (1167 cents) and divide this by 100 to find the number of dollars.\\nUse the modulus operator again to find out the remainder after subtracting the maximum amount of quarters (17 cents).\\nSubtract this remainder (17 cents) from the previous remainder (67 cents) and divide this by 25 to find out the number of quarters.\\nFollow the same steps for the dimes, nickels and pennies.\\nDisplay the result for your cashier! (the amount of dollars, quarters, dimes, nickels and pennies that (s)he would have to give back)`\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# cashier code\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<a id='step4'><\\/a>\\n4. Download and Load Weather Files\\nThere are various options provided in bifacial_radiance to load weatherfiles. getEPW is useful because you just set the latitude and longitude of the location and it donwloads the meteorologicla data for any location.\\n\",\"targets\":\"# Pull in meteorological data using pyEPW for any global lat\\/lon\\nepwfile = demo.getEPW(lat = 37.5, lon = -77.6)  # This location corresponds to Richmond, VA.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"... and we can draw the decision boundary using pyplot:\\n\",\"targets\":\"x_min, x_max = X_train[:, 0].min() - .5, X_train[:, 0].max() + .5\\ny_min, y_max = X_train[:, 1].min() - .5, X_train[:, 1].max() + .5\\nxs = np.arange(x_min, x_max, 0.5)\\nfig,axes = plt.subplots()\\naxes.set_aspect('equal')\\naxes.set_title('Setosa classification')\\naxes.set_xlabel('Sepal length')\\naxes.set_ylabel('Sepal width')\\naxes.set_xlim(x_min, x_max)\\naxes.set_ylim(y_min, y_max)\\nplt.sca(axes)\\nplt.scatter(X_train[:, 0][y_train == 0], X_train[:, 1][y_train == 0], c='red', marker='s')\\nplt.scatter(X_train[:, 0][y_train == 1], X_train[:, 1][y_train == 1], c='black', marker='x')\\nys = (-clf.intercept_[0]- xs * clf.coef_[0, 0]) \\/ clf.coef_[0, 1]\\nplt.plot(xs, ys, hold=True)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Achsen kontrollieren\\n\\nplt.xlim und plt.ylim um der range von den Achsen zu kontrollieren\\nplt.xscale(\\\"log\\\") für ein logaritmischer Achsen\\n\",\"targets\":\"plt.figure()\\nplt.plot(x, y1)\\nplt.xlim((1, 5))\\nplt.ylim((-10, 10))\\nplt.xscale(\\\"log\\\")\\nplt.plot(x, y2)\\nplt.xscale(\\\"linear\\\")\\nplt.show()\\nplt.close()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create Fake Index Data\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmean = np.array([0.05\\/252 + 0.02\\/252, 0.03\\/252 + 0.02\\/252])\\nvolatility = np.array([0.2\\/np.sqrt(252), 0.05\\/np.sqrt(252)])\\nvariance = np.power(volatility,2)\\ncorrelation = np.array(\\n    [\\n        [1, 0.25],\\n        [0.25,1]\\n    ]\\n)\\ncovariance = np.zeros((2,2))\\nfor i in range(len(variance)):\\n    for j in range(len(variance)):\\n        covariance[i,j] = correlation[i,j]*volatility[i]*volatility[j]\\n\\ncovariance\\n\\nnames = ['foo','bar','rf']\\ndates = pd.date_range(start='2015-01-01',end='2018-12-31', freq=pd.tseries.offsets.BDay())\\nn = len(dates)\\nrdf = pd.DataFrame(\\n    np.zeros((n, len(names))),\\n    index = dates,\\n    columns = names\\n)\\n\\nnp.random.seed(1)\\nrdf.loc[:,['foo','bar']] = np.random.multivariate_normal(mean,covariance,size=n)\\nrdf['rf'] = 0.02\\/252\\n\\npdf = 100*np.cumprod(1+rdf)\\npdf.plot()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"$\\\\langle DM_{halos}\\\\rangle$ and $\\\\langle DM_{IGM}\\\\rangle$\\nThe fraction of free electrons present in halos should be equal to the fraction of diffuse gas in halos assuming the ionization state of the individual species is only dependent on redshift (and not gas density as well).\\n$$\\n\\\\begin{aligned}\\n\\\\frac{\\\\langle n_{e, halos}\\\\rangle}{\\\\langle n_{e, cosmic}\\\\rangle} & = \\\\frac{\\\\rho_{diffuse,halos}}{\\\\rho_{diffuse,cosmic}}\\\\\\n& = \\\\frac{\\\\rho_{b, halos}f_{hot}}{\\\\rho_{b, cosmic}f_{diffuse, cosmic}}\\\\\\n\\\\end{aligned}\\n$$\\nHere $\\\\rho_b$ refers to baryon density. $f_{hot}$ refers to the fraction of baryons in halos that is in the hot phase ($\\\\sim10^7$ K). The remaining baryons are either in the neutral phase or in dense objects like stars. Assuming halos have the same baryon mass fraction as the universal average ($\\\\Omega_b\\/\\\\Omega_M$)\\n$$\\n\\\\begin{aligned}\\n\\\\frac{\\\\langle n_{e, halos}\\\\rangle}{\\\\langle n_{e, cosmic}\\\\rangle} & = \\\\frac{\\\\rho_{m, halos}f_{hot}}{\\\\rho_{m, cosmic}f_{diffuse, cosmic}}\\\\\\n& = \\\\frac{f_{halos} f_{hot}}{f_{diffuse, cosmic}}\\\\\\n\\\\end{aligned}\\n$$\\n$f_{halos}$ can be computed as a function of redshift by integrating the halo mass function (HMF) times mass over some mass range and dividing it by the density of matter in the universe. This allows us to compute a line of sight integral of $\\\\langle n_{e, halos} \\\\rangle$ to get $\\\\langle DM_{halos}\\\\rangle$. $\\\\langle DM_{IGM}\\\\rangle$ is just obtained by subtracting this from $\\\\langle DM_{cosmic}\\\\rangle$.\\nApart from $f_{hot}$ being an obvious free parameter, we also allow variation in the radial extent of halos. This is encoded in the parameter $r_{max}$ which is the radial extent of halos in units of $r_{200}$. Setting $r_{max}>1$ (for all halos; currently it is mass independent) smoothly extends the NFW profile and the modifid profile of the encased diffuse baryons.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nhelp(frb_igm.average_DMhalos)\\n\\n# evaluation\\nfrb_igm.average_DMhalos(0.1)\\n\\n# get cumulative DM_halos\\ndm, zvals = frb_igm.average_DMhalos(0.1, cumul = True)\\ndm\\n\\nzvals\\n\\nfhot_array = [0.2, 0.5, 0.75]\\nrmax_array = [0.5, 1.0 , 2.0]\\n\\n\\n# <DM_halos> for different f_hot\\nfig, axs = plt.subplots(2,1, sharex=True, figsize = (8,7))\\nfig.tight_layout()\\nax1 = axs[0]\\n\\nfor f_hot in fhot_array:\\n    DM_halos, zeval = frb_igm.average_DMhalos(3, f_hot = f_hot, cumul=True)\\n    ax1.plot(zeval, DM_halos, label=\\\"{:0.1f}\\\".format(f_hot))\\nax1.legend(title=\\\"f_hot\\\")\\nax1.set_ylabel(r'$\\\\langle DM_{halos}\\\\rangle$ $pc~cm^{-3}$')\\n\\n# <DM_halos> for different rmax\\nax2 = axs[1]\\nfor rmax in rmax_array:\\n    DM_halos, zeval = frb_igm.average_DMhalos(3, rmax = rmax, cumul = True)\\n    ax2.plot(zeval, DM_halos, label=\\\"{:0.1f}\\\".format(rmax))\\nax2.legend(title=\\\"rmax\\\")\\nax2.set_xlabel('z')\\nax2.set_ylabel(r'$\\\\langle DM_{halos}\\\\rangle$ $pc~cm^{-3}$')\\nplt.show()\\n\\n# Limits of calculation\\nfrb_igm.average_DMhalos(3.1)\\n\\n# Failure above redshift 5\\nfrb_igm.average_DMhalos(5.1)\\n\\nhelp(frb_igm.average_DMIGM)\\n\\n# Sanity check. <DM_cosmic> - (<DM_halos> + <DM_IGM) = 0\\ndm, zvals = frb_igm.average_DM(0.1, cumul= True)\\ndm_halos, _ = frb_igm.average_DMhalos(0.1, cumul = True)\\ndm_igm, _ = frb_igm.average_DMIGM(0.1, cumul = True)\\n\\nplt.plot(zvals, dm - dm_halos - dm_igm)\\nplt.ylabel(r\\\"DM $pc~cm^{-3}$\\\")\\nplt.xlabel(\\\"z\\\")\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Background information on filtering\\nHere we give some background information on filtering in general,\\nand how it is done in MNE-Python in particular.\\nRecommended reading for practical applications of digital\\nfilter design can be found in Parks & Burrus (1987) [1] and\\nIfeachor & Jervis (2002) [2], and for filtering in an\\nM\\/EEG context we recommend reading Widmann et al. (2015) [7]_.\\nTo see how to use the default filters in MNE-Python on actual data, see\\nthe tut-filter-resample tutorial.\\nProblem statement\\nPractical issues with filtering electrophysiological data are covered\\nin Widmann et al. (2012) [6]_, where they conclude with this statement:\\nFiltering can result in considerable distortions of the time course\\n(and amplitude) of a signal as demonstrated by VanRullen (2011) [[3]_].\\nThus, filtering should not be used lightly. However, if effects of\\nfiltering are cautiously considered and filter artifacts are minimized,\\na valid interpretation of the temporal dynamics of filtered\\nelectrophysiological data is possible and signals missed otherwise\\ncan be detected with filtering.\\n\\nIn other words, filtering can increase signal-to-noise ratio (SNR), but if it\\nis not used carefully, it can distort data. Here we hope to cover some\\nfiltering basics so users can better understand filtering trade-offs and why\\nMNE-Python has chosen particular defaults.\\nFiltering basics\\nLet's get some of the basic math down. In the frequency domain, digital\\nfilters have a transfer function that is given by:\\n\\\\begin{align}H(z) &= \\\\frac{b_0 + b_1 z^{-1} + b_2 z^{-2} + \\\\ldots + b_M z^{-M}}\\n                 {1 + a_1 z^{-1} + a_2 z^{-2} + \\\\ldots + a_N z^{-M}} \\\\\\n         &= \\\\frac{\\\\sum_{k=0}^Mb_kz^{-k}}{\\\\sum_{k=1}^Na_kz^{-k}}\\\\end{align}\\nIn the time domain, the numerator coefficients $b_k$ and denominator\\ncoefficients $a_k$ can be used to obtain our output data\\n$y(n)$ in terms of our input data $x(n)$ as:\\n\\\\begin{align}:label: summations\\ny(n) &amp;= b_0 x(n) + b_1 x(n-1) + \\\\ldots + b_M x(n-M)\\n        - a_1 y(n-1) - a_2 y(n - 2) - \\\\ldots - a_N y(n -...\\n\",\"targets\":\"import numpy as np\\nfrom scipy import signal, fftpack\\nimport matplotlib.pyplot as plt\\n\\nfrom mne.time_frequency.tfr import morlet\\nfrom mne.viz import plot_filter, plot_ideal_filter\\n\\nimport mne\\n\\nsfreq = 1000.\\nf_p = 40.\\nflim = (1., sfreq \\/ 2.)  # limits for plotting\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Choose which one is smaller!\\nif num_galex1 < num_galex2:\\n    select_from_galex = idx_galex1\\nelse:\\n    select_from_galex = idx_galex2\\n\\nprint(len(select_from_galex))\\nmatch_galex = data_galex[select_from_galex]\\nc_selected_galex = c_galex[select_from_galex]\\n\\n# Select other catalog using GALEX again\\n# 2MASS\\nidx_2mass, idx_galex1, d2d, d3d = c_2mass.search_around_sky(c_selected_galex, sep_min)\\n\\n# WISE\\nidx_wise, idx_galex2, d2d, d3d = c_wise.search_around_sky(c_selected_galex, sep_min)\\n\\n\\nprint(\\\"Number of match in GALEX: \\\", len(c_selected_galex))\\nprint(\\\"Number of match in 2MASS: \\\", len(idx_2mass))\\nprint(\\\"Number of match in WISE : \\\", len(idx_wise))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFilter all Cats\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"4.2. River Mouth\\nIs Required: FALSE&nbsp;&nbsp;&nbsp;&nbsp;Type: STRING&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 0.1\\nDescribe if\\/how river mouth mixing or estuaries specific treatment is performed\\n\",\"targets\":\"# PROPERTY ID - DO NOT EDIT !  \\nDOC.set_id('cmip6.ocean.key_properties.nonoceanic_waters.river_mouth')  \\n\\n# PROPERTY VALUE: \\n# Set as follows: DOC.set_value(\\\"value\\\")  \\nDOC.set_value(\\\"Kz increase near river mouth (top 20 m)\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"EllipsesProject\\/MyEllipsesNotebook.ipynb\\\".\\nThe first task is:\\nModel training\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# hyperparams\\nepochs = 50\\nbatch_size = 64\\noptAlgo = Adam()\\n\\n# compile model\\nmodel.compile(optAlgo,loss=['binary_crossentropy','mse'], metrics=['accuracy'],loss_weights=[1.,.01])\\n\\n# values to track:\\nsave_to = 'best_model.h5'\\ncheckpoint = ModelCheckpoint(filepath=save_to,verbose=0, save_best_only=True)\\ncallbacks = [checkpoint]\\n\\n# train model\\nhistory = model.fit(X_train, [Y_train_class,Y_train_features], shuffle=True, batch_size=batch_size, \\n                             epochs=epochs, verbose=1, validation_split=0.3, callbacks = callbacks)\\n\\n# Plot training & validation accuracy values\\nplt.plot(history.history['class_acc'])\\nplt.plot(history.history['features_acc'])\\nplt.plot(history.history['val_class_acc'])\\nplt.plot(history.history['val_features_acc'])\\nplt.title('Model accuracy')\\nplt.ylabel('Accuracy')\\nplt.xlabel('Epoch')\\nplt.legend(['class_acc','features_acc','val_class_acc', 'val_features_acc'], loc='lower left')\\nplt.show()\\n\\n# Plot training & validation loss values (general loss)\\nplt.plot(history.history['loss'])\\nplt.plot(history.history['val_loss'])\\nplt.title('Model loss (General Loss)')\\nplt.ylabel('Loss')\\nplt.xlabel('Epoch')\\nplt.legend(['loss','val_loss'], loc='upper left')\\nplt.show()\\n\\n# Plot training & validation loss values (classification loss)\\nplt.plot(history.history['class_loss'])\\nplt.plot(history.history['val_class_loss'])\\nplt.title('Model loss (Classification Loss)')\\nplt.ylabel('Loss')\\nplt.xlabel('Epoch')\\nplt.legend(['class_loss','val_class_loss'], loc='upper left')\\nplt.show()\\n\\n# Plot training & validation loss values (features loss)\\nplt.plot(history.history['features_loss'])\\nplt.plot(history.history['val_features_loss'])\\nplt.title('Model loss (Features Loss)')\\nplt.ylabel('Loss')\\nplt.xlabel('Epoch')\\nplt.legend(['features_loss','val_features_loss'], loc='upper left')\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Define the model with the best parametrization\\n...\\n\\nclf.fit(X_train, y_train)\\nmean_absolute_error(y_test, clf.predict(X_test))\\n\\n# Plot the scatterplot\\nplt.scatter(y_test, clf.predict(X_test))\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFit the best model\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Another way to model the \\\"bag of words\\\" is to evaluate if the tweet has only positive words, only negative words, both positive and negative words or neither positive nor negative words.  Rewrite your code to keep track of all four totals.\\nStep 5: Count \\\"types\\\" of tweets. Rewrite the code from steps 1 & 3 and determin if each tweet has only positive works, only negative words, both positive and negative words or neither positive nor negative words. Keep total counts the number of each kind of tweet.\\n\",\"targets\":\"only_positive=0;\\nonly_negative=0;\\nboth_pos_and_neg=0;\\nneither_pos_nor_neg=0;\\n#Put your code here.\\n\\nfor tweet in tweets_list:\\n    positive_counter=0\\n    negative_counter=0\\n    tweet_processed=tweet.lower()\\n    for p in punctuation:\\n        tweet_processed=tweet_processed.replace(p,'')\\n        words=tweet_processed.split(' ')\\n        word_count = len(words)\\n        for word in words:\\n            if word in positive_words:\\n                positive_counter=positive_counter+1\\n            if word in negative_words:\\n                negative_counter=negative_counter+1\\n    if(positive_counter > 0):\\n        if(negative_counter > 0):\\n            both_pos_and_neg=both_pos_and_neg+1\\n        else:\\n            only_positive=only_positive+1;\\n    else:\\n        if(negative_counter > 0):\\n            only_negative=only_negative+1;\\n        else:\\n            neither_pos_nor_neg=neither_pos_nor_neg+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 \\\"Presentaciones\\/Notas\\/06_Versionamiento_git.ipynb\\\".\\nThe first task is:\\nEn caso de ser un repositorio nuevo o desear reinicializar (aceptar nuevas plantillas o mover el directorio), debemos crear el directorio .git y agregar los elementos que teniamos en nuestro directorio. Siempre que se agreguen (o se realiza cualquier actualización de los archivos y directorios, se sugiere realizar un commit para la indicación de la acción en nuestro historial).\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%%bash\\ncd herramientas\\ngit init\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Confusion Matrix\\n予測したものと正解の数\\n\",\"targets\":\"%matplotlib inline\\nimport matplotlib.pyplot as plt\\nimport numpy as np\\nimport itertools\\n\\ndef plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues):\\n    \\\"\\\"\\\"\\n    This function prints and plots the confusion matrix.\\n    Normalization can be applied by setting `normalize=True`.\\n    \\\"\\\"\\\"\\n    if normalize:\\n        cm = cm.astype('float') \\/ cm.sum(axis=1)[:, np.newaxis]\\n        print(\\\"Normalized confusion matrix\\\")\\n    else:\\n        print('Confusion matrix, without normalization')\\n\\n    print(cm)\\n\\n    plt.imshow(cm, interpolation='nearest', cmap=cmap)\\n    plt.title(title)\\n    plt.colorbar()\\n    tick_marks = np.arange(len(classes))\\n    plt.xticks(tick_marks, classes, rotation=45)\\n    plt.yticks(tick_marks, classes)\\n\\n    fmt = '.2f' if normalize else 'd'\\n    thresh = cm.max() \\/ 2.\\n    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\\n        plt.text(j, i, format(cm[i, j], fmt),\\n                 horizontalalignment=\\\"center\\\",\\n                 color=\\\"white\\\" if cm[i, j] > thresh else \\\"black\\\")\\n\\n    plt.tight_layout()\\n    plt.ylabel('True label')\\n    plt.xlabel('Predicted label')\\n\\n\\nfrom sklearn.metrics import confusion_matrix\\n\\nmatrix = confusion_matrix(y, ｃｌｆ.predict(X))\\nplot_confusion_matrix(matrix, ['A', 'B', 'C'], normalize=True)\\n\\n## クロスバリデーション\\nfor classifier, title in zip(classifiers, ['Decision Tree (depth=2)', 'KNN (k=1)', 'Kernel SVM', 'Iris Classifier']):\\n    scores = cross_val_score(classifier, X, y, cv=6)\\n    print(\\\"Cross Validation Score of %s\\\" % title)\\n    print(\\\"mean(%s) = %s\\\" % (scores, scores.mean()))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"13.765.202 lines in train.csv  \\n8.022.757 lines in test.csv  \\n\\nFew words about the dataset\\nPredictions is made in the USA corn growing states (mainly Iowa, Illinois, Indiana) during the season with the highest rainfall (as illustrated by Iowa for the april to august months)\\nThe Kaggle page indicate that the dataset have been shuffled, so working on a subset seems acceptable\\nThe test set is not a extracted from the same data as the training set however, which make the evaluation trickier\\nLoad the dataset\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%%time\\nfilename = \\\"data\\/reduced_train_100000.csv\\\"\\n#filename = \\\"data\\/reduced_train_100000.csv\\\"\\nraw = pd.read_csv(filename)\\nraw = raw.set_index('Id')\\n\\nraw['Expected'].describe()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"And the survival function.\\n\",\"targets\":\"sf = hf.MakeSurvival()\\nsf.ts, sf.ss\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Strings\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nStrings can be declared with either single or double quotes.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# This is an example observation from the dataset.\\n\\nexample_observation = []\\n\\nserialized_example = serialize_example(False, 4, b'goat', 0.9876)\\nserialized_example\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n例如，假设您从数据集中获得了一个观测值 [False, 4, bytes('goat'), 0.9876]。您可以使用 create_message() 创建和打印此观测值的 tf.Example 消息。如上所述，每个观测值将被写为一条 Features 消息。请注意，tf.Example 消息只是 Features 消息外围的包装器：\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"4. First steps with NetworkX.ipynb\\\".\\nThe first task is:\\nAside: dictionaries!\\nIn the examples above, you may have noticed that we used curly braces {} when defining attributes. The curly braces denote an object called a dictionary (dict). A dictionary is an object that stores key-value pairs. \\nFor example, I might want to be able to look up a bunch of people by their student IDs. To do that, I could create a dictionary with student IDs as keys, and names as values:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nstudents = {    # I was born in the 1980s...\\n    292883094: 'Bob Dole',\\n    940528892: 'Ross Perot',\\n    940927000: 'Janet Reno',\\n}\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Arg: quality and num_per_dim -> tradeoffs between quality and time spent running \\n# quality affects dense=False, and num_per_dim affects dense=True\\nckpt_path = '.\\/ckpt\\/exif_final\\/exif_final.ckpt'\\nexif_demo = demo.Demo(ckpt_path=ckpt_path, use_gpu=0, quality=3.0, num_per_dim=30)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nInitialize Demo Solver\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Building complete data set, with the small caveat that we don't seek to load all of the positions for time constraints (for now at least).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmax_step = 1000\\nstart_step = 1000\\nstride = 10\\nsize_data = max_step*nbC\\ndata = np.zeros( (max_step*nbC, size_off+1, nb_type ), dtype=float )\\nfor step in np.arange(start_step,stride*max_step+start_step,stride):\\n    # Distance from all atoms (saves time?)\\n    matrix = computeDistanceMatrix( positions[step,:,:], cell_lengths)\\n    for carbon in range(nbC):\\n        # Data Adress\\n        add_data = int((step-start_step)\\/stride)*nbC + carbon\\n        # C-C\\n        for carbon2 in range(nbC):\\n            # Gaussians at atomic site\\n            data[ add_data, 0, 0 ] += np.exp( -(matrix[carbon,carbon2]*matrix[carbon,carbon2])\\/(2*sigma_C*sigma_C) )\\n            # Gaussians with small displacement from site\\n            if carbon != carbon2:\\n                for i in range(size_off):\\n                    dist = getDistance( positions[step, carbon2, :], (positions[step,carbon,:]+positions_offset[i,:])%cell_lengths[0], cell_lengths )\\n                    data[ add_data, i+1, 0 ] += np.exp( -(dist*dist)\\/(2*sigma_C*sigma_C) )\\n        # C-O\\n        for oxygen in range(nbC,nb_atoms):\\n            # Gaussians at atomic site\\n            data[ add_data, 0, 1 ] += np.exp( -(matrix[carbon,oxygen]*matrix[carbon,oxygen])\\/(2*sigma_O*sigma_O) )\\n            # Gaussians with small displacement from site\\n            for i in range(size_off):\\n                dist = getDistance( positions[step, oxygen,:], (positions[step,carbon,:]+positions_offset[i,:])%cell_lengths[0], cell_lengths )\\n                data[ add_data, i+1, 1 ] += np.exp( -(dist*dist)\\/(2*sigma_O*sigma_O) )\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"5_root_finding_optimization.ipynb\\\".\\nThe first task is:\\nComments\\n\\nSecant method as shown is equivalent to linear interpolation\\nCan use higher order interpolation for higher order secant methods\\nConvergence is not quite quadratic\\nNot gauranteed to converge\\nDo not preserve brackets\\nAlmost as good as Newton's method if your initial guess is good.\\n\\nHybrid Methods\\nCombine attributes of methods with others to make one great algorithm to rule them all (not really)\\nGoals\\n\\nRobustness:  Given a bracket $[a,b]$, maintain bracket\\nEfficiency:  Use superlinear convergent methods when possible\\n\\nOptions\\n\\nMethods requiring $f'(x)$\\nNewtSafe (RootSafe, Numerical Recipes)\\nNewton's Method within a bracket, Bisection otherwise\\nMethods not requiring $f'(x)$\\nBrent's Algorithm (zbrent, Numerical Recipes)\\nCombination of bisection, secant and inverse quadratic interpolation\\n\\n\\nscipy.optimize package\\n\\nOptimization (finding extrema)\\nI want to find the extrema of a function $f(x)$ on a given interval $[a,b]$.\\nA few approaches:\\n - Bracketing Algorithms:  Golden-Section Search (linear)\\n - Interpolation Alogithms: Repeated parabolic interpolation\\n - Hybrid Algorithms \\nBracketing Algorithm (Golden Section Search)\\nGiven $f(x) \\\\in C[a,b]$ that is convex over an interval $x \\\\in [a,b]$ reduce the interval size until it brackets the minimum.\\nNote that we no longer have the $x=0$ help we had before so bracketing and doing bisection is a bit more tricky in this case.  In particular choosing your initial bracket is important!\\nGolden Section Search - The Idea\\nAssume $f(x)$ is unimodal (has a single minimum in the bracket) and given a bracket $[a,b]$, pick a point inside of the bracket that is not in the middle say $c$.  Since $f(x)$ is unimodal we know $f(c) < f(a)$ and $f(c) < f(b)$.  Now we attempt to choose a new point, say $d$, which has two possibilities:\\n1. $f(d) < f(c)$ in which case we know the minimum lies between $c$ and $b$.\\n2. $f(d) > f(c)$ in which case we know the minimum lies between $a$ and $c$\\n\\nGolden Section Search - Picking Intervals\\nWe also may want to choose the search points $c$ and...\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef f(t):\\n    \\\"\\\"\\\"Simple function for minimization demos\\\"\\\"\\\"\\n    return -3.0 * numpy.exp(-(t - 0.3)**2 \\/ (0.1)**2) \\\\\\n           +      numpy.exp(-(t - 0.6)**2 \\/ (0.2)**2) \\\\\\n           +      numpy.exp(-(t - 1.0)**2 \\/ (0.2)**2) \\\\\\n           +      numpy.sin(t)                        \\\\\\n           -      2.0\\n\\nt = numpy.linspace(0, 2, 200)\\nfig = plt.figure()\\naxes = fig.add_subplot(1, 1, 1)\\naxes.plot(t, f(t))\\naxes.set_xlabel(\\\"t (days)\\\")\\naxes.set_ylabel(\\\"People (N)\\\")\\naxes.set_title(\\\"Decrease in Population due to SPAM Poisoning\\\")\\n\\nplt.show()\\n\\nphi = (numpy.sqrt(5.0) - 1.0) \\/ 2.0\\n\\nTOLERANCE = 1e-4\\nMAX_STEPS = 100\\n\\na = 0.3\\nb = 0.5\\nc = b - phi * (b - a)\\nd = a + phi * (b - a)\\n\\nsuccess = False\\nfor n in xrange(1, MAX_STEPS):\\n    fc = f(c)\\n    fd = f(d)\\n    if fc < fd:\\n        b = d\\n        d = c\\n        c = b - phi * (b - a)\\n    else:\\n        a = c\\n        c = d \\n        d = a + phi * (b - a)\\n    if numpy.abs(c - d) < TOLERANCE:\\n        success = True\\n        break\\n        \\nif success:\\n    print \\\"Success!\\\"\\n    print \\\"  t* = %s\\\" % str((b + a) \\/ 2.0)\\n    print \\\"  f(t*) = %s\\\" % f((b + a) \\/ 2.0)\\n    print \\\"  number of steps = %s\\\" % n\\nelse:\\n    print \\\"Reached maximum number of steps!\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Closure a dekorator.ipynb\\\".\\nThe first task is:\\nAko tento hack opravit?\\n\\nzabalime to cele do funkcie\\nzmenime mutable objekt za immutable\\ndefinujeme nonlokalnu premennu\\nvratime vnutornu funkciu\\nCan you write Python code for it?\\n\",\"targets\":\"\\ncounter = [0] # Toto je ta globalny mutable objekt \\ndef measure_add(a, result, counter=counter):\\n    if counter[0] % 200000 == 0:\\n        print_memory_usage()\\n    counter[0] = counter[0] + 1\\n    return a + result\\n\\n# toto tu mam en pre kontrolu, aby som nespravil chybu\\ndef make_adder():\\n    counter = 0\\n    def adder(a, result):\\n        nonlocal counter\\n        if counter % 2000000 == 0:\\n            print_memory_usage()\\n        counter += 1\\n        return a+result\\n    return adder\",\"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_timeseries_update.ipynb\\\".\\nThe first task is:\\nExercise: write a python function named days_until that accepts one argument (a datetime.date) and returns the number of days between today and that date. Apply your function to \\n\\nMay 5, 2017 (day the UG project is due)\\nYour birthday\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef days_until(date):\\n    today = dt.date.today()\\n    numb_days = date - today\\n    \\n    return numb_days.days\\n\\nproject_due = dt.date(2017, 5, 5)\\n\\ndays_until(project_due)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%output filename=\\\"macaw_plot\\\" fig=\\\"png\\\" holomap=\\\"gif\\\"\\nparrot = hv.RGB.load_image('..\\/assets\\/macaw.png')\\nparrot\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExporting specific files\\nDuring interactive exploration in the IPython Notebook, your results are always visible within the notebook itself, but you can explicitly request that any IPython cell is also exported to an external file on disk:\",\"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_CorrectiveSolutions-6nodes-2loops.ipynb\\\".\\nThe first task is:\\nCompute H matrix\\nCan you write Python code for it?\\n\",\"targets\":\"\\nS1.compute_H()\\n\\nS1.H.subs(datav)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"A 'many-to-one' zone connectivity occurred in this time step relative to the previous time step, meaning neither speciation or extinction were triggered by zone change. (See zone connectivity table above.)\\nThe same two taxa of time 0 exist in time 1. Their geographic range is all that changed.\\n\",\"targets\":\"se.taxa_data_frame\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"4. Beam Pipeline\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport apache_beam as beam\\n\\n\\ndef run_pipeline(runner, opts):\\n    \\n    print(\\\"Sink train data files: {}\\\".format(Params.TRANSFORMED_TRAIN_DATA_FILE_PREFIX))\\n    print(\\\"Sink data files: {}\\\".format(Params.TRANSFORMED_EVAL_DATA_FILE_PREFIX))\\n    print(\\\"Temporary directory: {}\\\".format(Params.TEMP_DIR))\\n    print(\\\"\\\")\\n    \\n    \\n    with beam.Pipeline(runner, options=opts) as pipeline:\\n        with impl.Context(Params.TEMP_DIR): \\n    \\n            ###### analyze & transform train #########################################################\\n            if(runner=='DirectRunner'):\\n                print(\\\"\\\")\\n                print(\\\"Transform training data....\\\")\\n                print(\\\"\\\")\\n            \\n            step = 'train'\\n            source_query = get_source_query(step)\\n            \\n            # Read raw train data from BQ and cleanup\\n            raw_train_data = (\\n              pipeline\\n              | '{} - Read Data from BigQuery'.format(step) >> beam.io.Read(beam.io.BigQuerySource(query=source_query, use_standard_sql=True))\\n              | '{} - Extract Features'.format(step) >> beam.Map(get_features)\\n            )\\n            \\n            # create a train dataset from the data and schema\\n            raw_train_dataset = (raw_train_data, raw_metadata)\\n            \\n            # analyze and transform raw_train_dataset to produced transformed_train_dataset and transform_fn\\n            transformed_train_dataset, transform_fn = (\\n                raw_train_dataset \\n                | '{} - Analyze & Transform'.format(step) >> impl.AnalyzeAndTransformDataset(preprocessing_fn)\\n            )\\n            \\n            # get data and schema separately from the transformed_train_dataset\\n            transformed_train_data, transformed_metadata = transformed_train_dataset\\n\\n            # write transformed train data to sink\\n            _ = (\\n                transformed_train_data \\n                | '{} - Write Transformed Data as tfrecords'.format(step) >> beam.io.tfrecordio.WriteToTFRecord(\\n                   ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# With cropping then resizing then YUV\\ni = 0\\nfor camera in [\\\"left\\\", \\\"center\\\", \\\"right\\\"]:\\n    image = load_img(\\\"data\\/\\\"+data_frame.iloc[7100][camera].strip())\\n    image = img_to_array(image).astype(np.uint8)\\n    image = image[55:135, :, :]\\n    image = imresize(image, (32, 16, 3))\\n    yuv = cv2.cvtColor(image.astype(\\\"uint8\\\"), cv2.COLOR_RGB2YUV)\\n    hsv[:, :, 0] = hsv[:, :, 0] * 0\\n    hsv[:, :, 1] = hsv[:, :, 1] * 0\\n    plt.subplot(1, 3, i+1)\\n    plt.imshow(yuv)\\n    plt.axis('off')\\n    plt.title(camera)\\n    i += 1\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nConverted to YUV colour space and showing only the V channel\",\"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\\/IPython\\/bootcamp_pandas-clean.ipynb\\\".\\nThe first task is:\\nExercise. \\n\\nConstruct a list of countries with countries = weo[['ISO', 'Country']]; that is, without applying the drop_duplicates method.  How large is it?  How many duplicates have we dropped?  \\nWhat are the country codes (ISO) for Argentina and the United States?  \\nWhat are the variable codes (WEO Subject Code) for government debt (gross debt, percent of GDP) and net lending\\/borrowing (also percent of GDP)?  \\n\\nComment. Now that we have the country and variable codes, we can be more explicit about what we want.  We want observations with those country and variable codes.  \\nWe work up to the solution one step at a time.  \\nComparisons for series\\nWe can construct comparisons for series (dataframe columns) much as we did with simple variables.  The difference is that we get a complete column of True\\/False responses, not just one.  \\nMutiple comparisons have a different syntax than we saw earlier: and is replaced by &amp;, and or is replaced by |.  And when we have more than one comparison, we need to enclose them in parentheses.  \\nExamples.  Consider the comparisons:  \\n\\nsmall['Units'] == 'National currency'\\nsmall['2011'] &gt;= 100\\n(small['Units'] == 'National currency') &amp; (small['2011'] &gt;= 100)\\n(small['Units'] == 'National currency') | (small['2011'] &gt;= 100)\\n\\nRemind yourself what the &amp; and | do.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nsmall['Units'] == 'National currency'\\n\\nsmall['2011'] >= 100\\n\\n(small['Units'] == 'National currency') & (small['2011'] >= 100)\\n\\n(small['Units'] == 'National currency') | (small['2011'] >= 100)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"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.\\n\",\"targets\":\"satz = \\\"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(XXXXX):\\n    XXXXXX = 0\\n    for XXXXXX in elem:\\n        if XXXXXX.isupper():\\n            XXXXXXX += 1\\n    return  XXXXXXXX\\n\\n counting_caps(satz)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"MVideo\\/training model_2 (keras==2.0.8).ipynb\\\".\\nThe first task is:\\nРезультаты\\nРезультаты на тестовой выборке (20% от исходных данных)\\nцелевые переменные не нормировались!\\nCan you write Python code for it?\\n\",\"targets\":\"\\nget_score(model, X_test, y_test, sparse=50)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Issue_Embeddings\\/notebooks\\/08_Train_Repo_Specific_IssueLabeler.ipynb\\\".\\nThe first task is:\\nDo pre-processing (such as markdown parsing) to prepare data for model.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nparsed_df = iw.process_df(combined_sig_df)\\n\\nholdout_text = parsed_df[holdout_mask]\\n\\nlang_model_predict = np.stack(holdout_text.text.apply(lambda x: tcl.predict(x)[2].numpy()[pred_mask]).values)\\n\\nlang_model_predict.shape\\n\\nlen(iw.learn.data.classes)\\n\\nnp.array(iw.learn.data.classes)[pred_mask]\\n\\nlang_model_predict_df = pd.DataFrame(lang_model_predict)\\nlang_model_predict_df.columns = np.array(iw.learn.data.classes)[pred_mask]\\nlm_df = lang_model_predict_df[[x for x in label_columns if x in lang_model_predict_df.columns]]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Baseline model\\nNote that this is a very simple model to demonstrate training.\\nSuggestion for a stronger model:  Replace the convnet encoder with a point-based encoder like Transformer or Point Pillars and feed it points from the scene with rich features.  See function _sample_agent_points() in occupancy_flow_renderer.py for ideas on how to obtain such points and features.\\nRelevant publications:\\n\\nScene Transformer\\nOccupancy Flow Fields\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Number of channels output by the model.\\n# Occupancy of currently-observed vehicles: 1 channel.\\n# Occupancy of currently-occluded vehicles: 1 channel.\\n# Flow of all vehicles: 2 channels.\\nNUM_PRED_CHANNELS = 4\\n\\ndef _make_model_inputs(\\n    timestep_grids: occupancy_flow_grids.TimestepGrids,\\n    vis_grids: occupancy_flow_grids.VisGrids,\\n) -> tf.Tensor:\\n  \\\"\\\"\\\"Concatenates all occupancy grids over past, current to a single tensor.\\\"\\\"\\\"\\n  model_inputs = tf.concat(\\n      [\\n          vis_grids.roadgraph,\\n          timestep_grids.vehicles.past_occupancy,\\n          timestep_grids.vehicles.current_occupancy,\\n          tf.clip_by_value(\\n              timestep_grids.pedestrians.past_occupancy +\\n              timestep_grids.cyclists.past_occupancy, 0, 1),\\n          tf.clip_by_value(\\n              timestep_grids.pedestrians.current_occupancy +\\n              timestep_grids.cyclists.current_occupancy, 0, 1),\\n      ],\\n      axis=-1,\\n  )\\n  return model_inputs\\n\\ndef _make_model(\\n    model_inputs: tf.Tensor,\\n    config: occupancy_flow_metrics_pb2.OccupancyFlowTaskConfig,\\n) -> tf.keras.Model:\\n  \\\"\\\"\\\"Simple convolutional model.\\\"\\\"\\\"\\n  inputs = tf.keras.Input(tensor=model_inputs)\\n\\n  encoder = tf.keras.applications.ResNet50V2(\\n      include_top=False, weights=None, input_tensor=inputs)\\n\\n  num_output_channels = NUM_PRED_CHANNELS * config.num_waypoints\\n  decoder_channels = [32, 64, 128, 256, 512]\\n\\n  conv2d_kwargs = {\\n      'kernel_size': 3,\\n      'strides': 1,\\n      'padding': 'same',\\n  }\\n\\n  x = encoder(inputs)\\n\\n  for i in [4, 3, 2, 1, 0]:\\n    x = tf.keras.layers.Conv2D(\\n        filters=decoder_channels[i],\\n        activation='relu',\\n        name=f'upconv_{i}_0',\\n        **conv2d_kwargs)(\\n            x)\\n    x = tf.keras.layers.UpSampling2D(name=f'upsample_{i}')(x)\\n    x = tf.keras.layers.Conv2D(\\n        filters=decoder_channels[i],\\n        activation='relu',\\n        name=f'upconv_{i}_1',\\n        **conv2d_kwargs)(\\n            x)\\n\\n  outputs = tf.keras.layers.Conv2D(\\n      filters=num_output_channels,\\n      activation=None,\\n     ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"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\\nFor large alpha values, you can look at the selection of features in action\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#large\\nRid=linear_model.Lasso (alpha = 0.01)\\nRid.fit(X_train, y_train)\\nprint('\\\\n Appha:', Rid.alpha)\\nprint(' Coefficients:', Rid.coef_)\\nprint(' Score:', Rid.score(X_test,y_test))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"$ \\\\frac { d\\\\vec{v} } { d\\\\alpha_1} = \\\\frac {1}{R} \\\\vec{n} = k \\\\vec{n} $\\nDerivative of vectors\\n$ \\\\vec{u} = u_v \\\\vec{v} + u_n\\\\vec{n} $\\n$ \\\\frac { d\\\\vec{u} } { d\\\\alpha_1} =  \\\\frac { d(u_v\\\\vec{v}) } { d\\\\alpha_1} + \\\\frac { d(u_n\\\\vec{n}) } { d\\\\alpha_1} = \\n \\\\frac { du_n } { d\\\\alpha_1} \\\\vec{n} + u_n \\\\frac { d\\\\vec{n} } { d\\\\alpha_1} + \\\\frac { du_v } { d\\\\alpha_1} \\\\vec{v} + u_v \\\\frac { d\\\\vec{v} } { d\\\\alpha_1} = \\\\frac { du_n } { d\\\\alpha_1} \\\\vec{n} - u_n k \\\\vec{v} + \\\\frac { du_v } { d\\\\alpha_1} \\\\vec{v} + u_v k \\\\vec{n}$\\nThen\\n$ \\\\frac { d\\\\vec{u} } { d\\\\alpha_1} = \\\\left( \\\\frac { du_v } { d\\\\alpha_1} - u_n k \\\\right) \\\\vec{v} + \\\\left( \\\\frac { du_n } { d\\\\alpha_1} + u_v k \\\\right) \\\\vec{n}$\\n$ \\\\frac { d\\\\vec{u} } { d\\\\alpha_2} = \\\\frac { d(u_n\\\\vec{n}) } { d\\\\alpha_2} + \\\\frac { d(u_v\\\\vec{v}) } { d\\\\alpha_2} = \\n \\\\frac { du_n } { d\\\\alpha_2} \\\\vec{n} + u_n \\\\frac { d\\\\vec{n} } { d\\\\alpha_2} + \\\\frac { du_v } { d\\\\alpha_2} \\\\vec{v} + u_v \\\\frac { d\\\\vec{v} } { d\\\\alpha_2} = \\\\frac { du_n } { d\\\\alpha_2} \\\\vec{n} + \\\\frac { du_v } { d\\\\alpha_2} \\\\vec{v} $\\nBase Vectors $\\\\vec{R}_1, \\\\vec{R}_2, \\\\vec{R}_3$\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nR_alpha=r+alpha3*n\\nR_alpha\\n\\nR1=R_alpha.diff(alpha1)\\nR2=R_alpha.diff(alpha2)\\nR3=R_alpha.diff(alpha3)\\n\\nR1\\n\\nR1x = R1.dot(N.i)\\n\\nsimplify(R1x)\\n\\nR1z = R1.dot(N.k)\\nsimplify(R1z)\\n\\nR2\\n\\nR3\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<h1> 3. Make sure outputs do not clobber each other <\\/h1>\\n\\nWe append the trial-number to the output directory.\\n\",\"targets\":\"!grep -A 5 \\\"trial\\\" taxifare\\/trainer\\/task.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 \\\"Notebooks\\/Unused\\/Resizing.ipynb\\\".\\nThe first task is:\\nResize the image with default downsampling:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%timeit im.resize((hsize, vsize))\\nresized_im = im.resize((hsize, vsize), Image.NEAREST)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<a name=\\\"equilibrium\\\"><\\/a>\\nEquilibrium\\nEquilibrium is at 0.693.  Why?  Consider what the cost is measuring, the binary cross entropy.  If we have random guesses, then we have as many 0s as we have 1s.  And on average, we'll be 50% correct.  The binary cross entropy is:\\n\\\\begin{align}\\n\\\\sum_i \\\\text{X}_i * \\\\text{log}(\\\\tilde{\\\\text{X}}_i) + (1 - \\\\text{X}_i) * \\\\text{log}(1 - \\\\tilde{\\\\text{X}}_i)\\n\\\\end{align}\\nWhich is written out in tensorflow as:\\npython\\n(-(x * tf.log(z) + (1. - x) * tf.log(1. - z)))\\nWhere x is the discriminator's prediction of the true distribution, in the case of GANs, the input images, and z is the discriminator's prediction of the generated images corresponding to the mathematical notation of $\\\\tilde{\\\\text{X}}$.  We sum over all features, but in the case of the discriminator, we have just 1 feature, the guess of whether it is a true image or not.  If our discriminator guesses at chance, i.e. 0.5,  then we'd have something like:\\n\\\\begin{align}\\n0.5 * \\\\text{log}(0.5) + (1 - 0.5) * \\\\text{log}(1 - 0.5) = -0.693\\n\\\\end{align}\\nSo this is what we'd expect at the start of learning and from a game theoretic point of view, where we want things to remain.  So unlike our previous networks, where our loss continues to drop closer and closer to 0, we want our loss to waver around this value as much as possible, and hope for the best.\\n\",\"targets\":\"equilibrium = 0.693\\nmargin = 0.2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Analyze the mesh fission rate tally\\n\",\"targets\":\"# Find the mesh tally with the StatePoint API\\ntally = sp.get_tally(name='mesh tally')\\n\\n# Print a little info about the mesh tally to the screen\\nprint(tally)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Apply the Classifier we trained to the test data (which, remember, it has never seen before)\\nclf.predict(test[features])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nHuzzah! We have done it! We have officially trained our random forest Classifier! Now let's play with it. The Classifier model itself is stored in the clf variable.\\nApply Classifier To Test Data\\nIf you have been following along, you will know we only trained our classifier on part of the data, leaving the rest out. This is, in my humble opinion, the most important part of machine learning. Why? Because by leaving out a portion of the data, we have a set of data to test the accuracy of our model!\\nLet's do that now.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Az ábra paramétereit (title, ylabel stb.) a matplotlibben megszokott módon állíthatjuk be.\\nElsőként növeljük meg alapértelmezetten a tengelyfeliratokat:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nrcParams[\\\"font.size\\\"]=15\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Building a Coding Tree\\nThe module heapq provides priority queues.  The api is given at https:\\/\\/docs.python.org\\/3\\/library\\/heapq.html.\\nWe will use two methods:\\n* heapq.heappush(H, p)\\n  pushes the priority p onto the heap.  For this to be possible, p has to be an object of a class that provides the \\n  method __lt__.  The expression p.__lt__(q) is True if p is smaller than q.\\n* heapq.heappop(H) \\n  removes and returns the element from the heap H that has the highest priority, i.e. the smallest element.\\nThe implementation of this module represents heaps as arrays.  Therefore, \\n* to test whether a heap H is empty we can write H == [] since [] is the empty heap.\\n* to create an empty heap we write H = [],\\n* to get the element with the highest priority in the heap H we write H[0],\\n* to get the number of elements in H we can write len(H).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport heapq\\n\\nH = []\\nheapq.heappush(H, 7)\\nheapq.heappush(H, 1)\\nheapq.heappush(H, 0)\\nheapq.heappush(H, 6)\\nH\\n\\na = heapq.heappop(H)\\nprint('a = ', a)\\nH\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# parameters: number of samples and according length of acf\\nN = int( 1e2 )\\nN_acf_range = np.arange( - N + 1, N, 1 )\\n\\n# number of realizations for averaging    \\nN_real = int( 1e2 )\\n\\n# number of freq. points and freq. range\\nN_freq = 512            \\nOme = np.linspace(-np.pi, np.pi, N_freq)\\n\\n\\n# filtering noise?!\\nfiltered = 1\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nParameters\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"FADL1\\/L3CA2_rossmann.ipynb\\\".\\nThe first task is:\\n1.5.3 Test\\nCan you write Python code for it?\\n\",\"targets\":\"\\nm = md.get_learner(emb_szs, len(df.columns)-len(cat_vars), \\n                   0.04, 1, [1000,500], [0.001,0.01], y_range=y_range)\\nλr = 1e-3\\n\\nm.fit(λr, 3, metrics=[exp_rmspe])\\n\\nm.fit(λr, 3, metrics=[exp_rmspe], cycle_len=1)\\n\\nm.save('val0')\\n\\n# m.load('val0')\\n\\nx,y = m.predict_with_targs()\\n\\nexp_rmspe(x,y)\\n\\npred_test = m.predict(True)\\n\\npred_test = np.exp(pred_test)\\n\\njoined_test['Sales'] = pred_test\\n\\ncsv_fn = f'{PATH}tmp\\/sub.csv'\\n\\njoined_test[['Id','Sales']].to_csv(csv_fn, index=False)\\n\\nFileLink(csv_fn)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Algorithm\\/Itertools.ipynb\\\".\\nThe first task is:\\nislice returns selcted item by index\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom itertools import * \\nprint('Stop at 5')\\nfor i in islice(range(100), 5):\\n    print(i, end =' ')\\nprint('\\\\n')\\n\\nprint('start at 5, and stop at 10')\\nfor i in islice(range(100), 5, 10):\\n    print(i, end=' ')\\nprint('\\\\n')\\n\\nprint('by ten to 100')\\nfor i in islice(range(100), 0,100, 10):\\n    print(i, end=' ')\\nprint('\\\\n')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As you can see, our we have now stored the same raster data into two different types of variables:\\n-raster is a Gdal Dataset \\n-rasterArray is a numpy array \\nThe GDAL library also comes with a module gdal_array that works as an interface between NumPy and GDAL. Gdal_array reads and writes raster files to and from NumPy arrays directly from file:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom osgeo import gdal_array\\n#from osgeo import gdalnumeric\\n\\n# Read raster data as numeric array from file\\nrasterArray = gdal_array.LoadFile(filepath)\",\"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 Science From Scratch\\/8 - Gradient Descent.ipynb\\\".\\nThe first task is:\\nUsing The Gradient\\nHere is an example of using gradient descent to find the minimum of a 3-dimensional vector:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef dot(v, w):\\n    \\\"\\\"\\\"v_1 * w_1 + ... + v_n * w_n\\\"\\\"\\\"\\n    return sum(v_i * w_i for v_i, w_i in zip(v, w))\\n\\ndef vector_subtract(v, w):\\n    \\\"\\\"\\\"subtracts corresponding elements\\\"\\\"\\\"\\n    return [v_i - w_i for v_i, w_i in zip(v, w)]\\n\\ndef sum_of_squares(v):\\n    \\\"\\\"\\\"v_1 * v_1 + ... + v_n * v_n\\\"\\\"\\\"\\n    return dot(v, v)\\n\\ndef squared_distance(v, w):\\n    \\\"\\\"\\\"(v_1 - w_1) ** 2 + ... + (v_n - w_n) ** 2\\\"\\\"\\\"\\n    return sum_of_squares(vector_subtract(v, w))\\n\\ndef distance(v, w):\\n    return math.sqrt(squared_distance(v, w))\\n\\ndef step(v, direction, step_size):\\n    \\\"\\\"\\\"move step_size in the direction from v\\\"\\\"\\\"\\n    return [v_i + step_size * direction_i for v_i, direction_i in zip(v, direction)]\\n\\ndef sum_of_squares_gradient(v):\\n    return [2 * v_i for v_i in v]\\n\\n# pick a random starting point\\nv = [random.randint(-10,10) for i in range(3)]\\n\\ntolerance = 0.0001\\n\\nwhile True:\\n    gradient = sum_of_squares_gradient(v) # compute the gradient at v\\n    next_v = step(v, gradient, -0.01) # take a negative gradient step\\n    if distance(next_v, v) < tolerance: # stop if we're converging\\n        break\\n    v = next_v # continue if we're not\\nv\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Another benefit of this kind of model is that the last convolutional layer has to learn to classify each part of the image (since there's only an average pooling layer after). Let's create a function that grabs the output of this layer (which is the 4th-last layer of our model).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nl = lrg_model.layers\\nconv_fn = K.function([l[0].input, K.learning_phase()], l[-4].output)\\n\\ndef get_cm(inp, label):\\n    conv = conv_fn([inp,0])[0, label]\\n    return scipy.misc.imresize(conv, (360,640), interp='nearest')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"3. 利用PyTorch的Tensor和autograd实现\\n两层网络的反向求导比较容易，但如果层数加多，在手动求导就会变得很复杂。因此深度学习平台都提供了自动求导功能，PyTorch的Autograd中的自动求导功能可以使反向求导简捷且灵活。要注意的是计算图的构建需要用autograd中的Variable将需要并入计算图中的变量进行封装，并设置相关属性。\\n\",\"targets\":\"import torch as T\\nfrom torch.autograd import Variable\\n\\n#先定义网络结构: batch_size, Input Dimension, Hidden Dimension, Output Dimension \\nN, D_in, D_hidden, D_out = 10, 20, 30, 5  \\n\\n#随机生成输入和输出数据, 并用Variable对输入输出进行封装，同时在计算图形中不要求求导\\nx = Variable(T.randn(N, D_in), requires_grad=False)\\ny = Variable(T.randn(N, D_out), requires_grad=False)\\n\\n#对输入层和输出层的参数进行初始化，并用Variable封装，同时要求求导\\nw1 = Variable(T.randn(D_in, D_hidden), requires_grad=True)\\nw2 = Variable(T.randn(D_hidden, D_out), requires_grad=True)\\n\\nlearning_rate = 0.001\\n\\n#循环更新参数，每个循环前向和反向各计算一次\\nfor i in xrange(50):\\n    \\n    # 计算前向通道\\n    #mm should also work as x is a matrix. The matrix multiplication will be summarized in another post\\n    h_linear = x.matmul(w1)     #10x20 and 20x30 produce 10x30, which is the shape of h_linear\\n    h_relu = h_linear.clamp(min=0) #note one have to use np.maximum but not np.max, 10x30\\n    y_pred = h_relu.matmul(w2)  #10x30 and 30x5 produce 10x5\\n    \\n    #定义代价函数\\n    loss = 0.5 * (y_pred - y).pow(2).sum() #sum squared error as loss\\n    \\n    loss.backward()\\n    \\n    \\n    #梯度下降法更新参数\\n    w1.data -= learning_rate * w1.grad.data  #note that we are updating the 'data' of Variable w1\\n    w2.data -= learning_rate * w2.grad.data\\n    \\n    #PyTorch中，将grad中的值在循环中进行累积，当不须此操作时，应清零\\n    w1.grad.data.zero_()\\n    w2.grad.data.zero_()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Mixmatch\\/streetview_dataset\\/parse_data_to_tfrecord_main.ipynb\\\".\\nThe first task is:\\nstreetview_v3-test\\nThis test set uses all TC11 images as positive cases, and handpick UCF images with confidence < 0.2 as negative cases.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Filter UCF images and copy files for furthur handpicking test set.\\nfor i in range(int(0.9 * INPUT_RECORD_CNT), INPUT_RECORD_CNT):\\n    file_name = \\\".\\/streetlearn_detections_tfexample-\\\" + str(i).zfill(5) + \\\"-of-01000.tfrecord\\\"\\n    parsed_image_dataset = read_tfrecord(os.path.join(INPUT_RECORD_DIR, file_name))\\n    filter_image_with_confidence_threshold(parsed_image_dataset, INPUT_UCF_IMG_DIR, OUTPUT_UCF_IMG_DIR, 0.2)\\n\\n# Build streetview_v3_64-test. Write test tfrecord from TC11 dataset and filtered UCF\\ntest_writer = tf.io.TFRecordWriter(OUTPUT_RECORD_DIR + OUTPUT_TEST_RECORD_FILENAME)\\ntest_image_path = os.path.join(INPUT_TC11_IMG_DIR, 'img')\\nwrite_tfrecord_from_images(test_image_path, 1, test_writer)\\nwrite_tfrecord_from_images(INPUT_UCF_FILTER_IMG_DIR, 0, test_writer)\\ntest_writer.close()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Check the training-time forward pass by checking means and variances\\n# of features both before and after spatial batch normalization\\n\\nN, C, H, W = 2, 3, 4, 5\\nx = 4 * np.random.randn(N, C, H, W) + 10\\n\\nprint('Before spatial batch normalization:')\\nprint('  Shape: ', x.shape)\\nprint('  Means: ', x.mean(axis=(0, 2, 3)))\\nprint('  Stds: ', x.std(axis=(0, 2, 3)))\\n\\n# Means should be close to zero and stds close to one\\ngamma, beta = np.ones(C), np.zeros(C)\\nbn_param = {'mode': 'train'}\\nout, _ = spatial_batchnorm_forward(x, gamma, beta, bn_param)\\nprint('After spatial batch normalization:')\\nprint('  Shape: ', out.shape)\\nprint('  Means: ', out.mean(axis=(0, 2, 3)))\\nprint('  Stds: ', out.std(axis=(0, 2, 3)))\\n\\n# Means should be close to beta and stds close to gamma\\ngamma, beta = np.asarray([3, 4, 5]), np.asarray([6, 7, 8])\\nout, _ = spatial_batchnorm_forward(x, gamma, beta, bn_param)\\nprint('After spatial batch normalization (nontrivial gamma, beta):')\\nprint('  Shape: ', out.shape)\\nprint('  Means: ', out.mean(axis=(0, 2, 3)))\\nprint('  Stds: ', out.std(axis=(0, 2, 3)))\\n\\n# Check the test-time forward pass by running the training-time\\n# forward pass many times to warm up the running averages, and then\\n# checking the means and variances of activations after a test-time\\n# forward pass.\\n\\nN, C, H, W = 10, 4, 11, 12\\n\\nbn_param = {'mode': 'train'}\\ngamma = np.ones(C)\\nbeta = np.zeros(C)\\nfor t in range(50):\\n  x = 2.3 * np.random.randn(N, C, H, W) + 13\\n  spatial_batchnorm_forward(x, gamma, beta, bn_param)\\nbn_param['mode'] = 'test'\\nx = 2.3 * np.random.randn(N, C, H, W) + 13\\na_norm, _ = spatial_batchnorm_forward(x, gamma, beta, bn_param)\\n\\n# Means should be close to zero and stds close to one, but will be\\n# noisier than training-time forward passes.\\nprint('After spatial batch normalization (test-time):')\\nprint('  means: ', a_norm.mean(axis=(0, 2, 3)))\\nprint('  stds: ', a_norm.std(axis=(0, 2, 3)))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSpatial Batch Normalization\\nWe already saw that batch normalization is a very useful technique for training deep fully-connected networks. Batch normalization can also be used for convolutional networks, but we need to tweak it a bit; the modification will be called \\\"spatial batch normalization.\\\"\\nNormally batch-normalization accepts inputs of shape (N, D) and produces outputs of shape (N, D), where we normalize across the minibatch dimension N. For data coming from convolutional layers, batch normalization needs to accept inputs of shape (N, C, H, W) and produce outputs of shape (N, C, H, W) where the N dimension gives the minibatch size and the (H, W) dimensions give the spatial size of the feature map.\\nIf the feature map was produced using convolutions, then we expect the statistics of each feature channel to be relatively consistent both between different images and different locations within the same image. Therefore spatial batch normalization computes a mean and variance for each of the C feature channels by computing statistics over both the minibatch dimension N and the spatial dimensions H and W.\\nSpatial batch normalization: forward\\nIn the file neural_network\\/layers.py, implement the forward pass for spatial batch normalization in the function spatial_batchnorm_forward. Check your implementation by running the following:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"ImageSimilarity_and_ClusterDemo.ipynb\\\".\\nThe first task is:\\nTo check whether the file search has succeeded, display some found images to get a feeling of the data we are going to deal with.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimg1=imread(jpegFilePaths[0])\\nimg2=imread(jpegFilePaths[1388])\\nimg3=imread(jpegFilePaths[1389])\\n\\n#Creates two subplots and unpacks the output array immediately\\nf, (ax1, ax2,ax3) = plt.subplots(1, 3, sharex='all', sharey='all')\\nax1.axis('off')\\nax2.axis('off')\\nax3.axis('off')\\n\\nax1.set_title(\\\"Image #0\\\")\\nax1.imshow(img1)\\nax2.set_title(\\\"Image #1388\\\")\\nax2.imshow(img2)\\nax3.set_title(\\\"Image #1389\\\")\\nax3.imshow(img3)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Below we plot the smoothed probability of the economy operating in a low-production state, and again include the NBER recessions for comparison.\\n\",\"targets\":\"fig, ax = plt.subplots(figsize=(12,3))\\n\\nax.plot(res_filardo.smoothed_marginal_probabilities[0])\\nax.fill_between(usrec.index, 0, 1, where=usrec['USREC'].values, color='gray', alpha=0.2)\\nax.set_xlim(dta_filardo.index[6], dta_filardo.index[-1])\\nax.set(title='Smoothed probability of a low-production state');\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"0. General note\\n\\n\\nThis notebook shows an example of how to conduct equation of state fitting for the pressure-volume-temperature data using pytheos.\\n\\n\\nAdvantage of using pytheos is that you can apply different pressure scales and different equations without much coding.  \\n\\n\\nWe use data on SiC from Nisr et al. (2017, JGR-Planet).\\n\\n\\n1. Global setup\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport numpy as np\\nimport uncertainties as uct\\nimport pandas as pd\\nfrom uncertainties import unumpy as unp\\nimport matplotlib.pyplot as plt\\nimport pytheos as eos\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"And now applying this on some real data\\nThese exercises are based on the PyCon tutorial of Brandon Rhodes (so all credit to him!) and the datasets he prepared for that. You can download these data from here: titles.csv and cast.csv and put them in the \\/data folder.\\ncast dataset: different roles played by actors\\/actresses in films\\n\\ntitle: title of the film\\nname: name of the actor\\/actress\\ntype: actor\\/actress\\nn: the order of the role (n=1: leading role)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncast = pd.read_csv('data\\/cast.csv')\\ncast.head()\\n\\ntitles = pd.read_csv('data\\/titles.csv')\\ntitles.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Broadcasting\\nBroadcasting is Numpy's terminology for performing mathematical operations between arrays of different shapes. If certain assumptions hold, the smaller of the two arrays is said to be broadcast to the size of the larger array in order to make the two arrays compatible so  element-to-element operations can be performed. <a href=\\\"http:\\/\\/eli.thegreenplace.net\\/2015\\/broadcasting-arrays-in-numpy\\/\\\">Read more<\\/a>.\\n\",\"targets\":\"macro_nutrients = np.array([[0.3, 2.5, 3.5],\\n                            [2.9, 27.5, 0],\\n                            [0.4, 1.3, 23.9],\\n                            [14.4, 6, 2.3]])\\ncalories_per_macro = np.array([9, 4, 4])\\nmacro_nutrients * calories_per_macro\\n\\narr4 = np.arange(0, 10)\\narr4\\n\\narr4[0:4] = 10\\narr4\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"3.3- Defining the choice set for each latent class\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Set the available alternatives for each latent class\\n# Each array entials the alternatives available in the choice set for each latent class \\n# NOTE: By default the code does not require the user to specify the choice set\\n#       for each class. The code assumes that all alternatives are available in the choice\\n#       set for each latent class.\\n# We are assuming that the bike alternative does not exist in the choice set for latent class 1\\n# We are assuming that all alternatives are available for latent class 2\\navail_alts = (np.array([1,2,4,5,6]),\\n              np.array([1,2,3,4,5,6]))\",\"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\\/quantopian_research_public\\/notebooks\\/lectures\\/Random_Variables\\/notebook.ipynb\\\".\\nThe first task is:\\nNow let's see how a theoretical normal curve fits against the actual values.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nx = np.linspace(-(sample_mean + 4 * sample_std_dev), (sample_mean + 4 * sample_std_dev), len(returns))\\nsample_distribution = ((1\\/(sample_std_dev * 2 * np.pi)) * \\n                       np.exp(-(x - sample_mean)*(x - sample_mean) \\/ (2 * sample_std_dev * sample_std_dev)))\\nplt.hist(returns.price, bins = 20, normed = True);\\nplt.plot(x, sample_distribution)\\nplt.xlabel('Value')\\nplt.ylabel('Occurrences');\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Calculate the Average Noise\\nNote: this will compute the average spectrogram using all of the \\\"noise\\\" spectrograms in the primary_small data. This wil take a bit of time\\n\",\"targets\":\"zz = zipfile.ZipFile(mydatafolder + '\\/' + 'primary_small.zip')\\ncsv_data = zz.namelist()[1:]\\n        \\ndata = []\\nN = 1\\nfor i,v in enumerate(csv_data):\\n    d = zz.open(v).read()\\n    aca = ibmseti.compamp.SimCompamp(d)\\n    if aca.header()['signal_classification'] == 'noise':\\n        spec = aca.get_spectrogram()\\n        if len(data) == 0:\\n            data = spec\\n        else:\\n            data = data + spec\\n            N += 1\\ndata = data\\/N\\nprint \\\"done\\\"\\n\\n# This is what the average noise plot looks like\\nfig, ax = plt.subplots(figsize=(10, 5))   \\nax.imshow(np.log(data), aspect = 0.5*float(data.shape[1]) \\/ data.shape[0])\\n\\n# This is the power spectrum of the image above.\\nplt.plot(np.sum(data, axis=0))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Data_analysis\\/SNP-indel-calling\\/dadi\\/MODIFIED_SPECTRA\\/01_modified_spectra_synthesis.ipynb\\\".\\nThe first task is:\\nThis is good convergence.\\nThe best-fit ancient migration model had a log likelihood of -12156. So only one log likelihood unit worse.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nll_s = 12156.061309\\nll_c = 12155.538032\\nD = 2 * (ll_s - ll_c)\\nD\\n\\n# calculate p-value for Chi-square dist.\\n# the weights specify a weighted sum of chi^2 distributions with 0 and 1 d.o.f\\n# this is because Tsc is 0 in the split_asym_mig_iso model and at the boundary of the parameter space\\np = dadi.Godambe.sum_chi2_ppf(D, weights=(0.5, 0.5))\\np\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Answer: 79.35%.\\n\\nAdding the feature Age as a condition in conjunction with Sex improves the accuracy by a small margin more than with simply using the feature Sex alone. Now it's your turn: Find a series of features and conditions to split the data on to obtain an outcome prediction accuracy of at least 80%. This may require multiple features and multiple levels of conditional statements to succeed. You can use the same feature multiple times with different conditions. \\nPclass, Sex, Age, SibSp, and Parch are some suggested features to try.\\nUse the survival_stats function below to to examine various survival statistics.\\nHint: To use mulitple filter conditions, put each condition in the list passed as the last argument. Example: [\\\"Sex == 'male'\\\", \\\"Age &lt; 18\\\"]\\n\",\"targets\":\"vs.survival_stats(data, outcomes, 'Sex', [\\\"Sex == 'male'\\\", \\\"Pclass == 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 \\\"Digital Text Analysis.ipynb\\\".\\nThe first task is:\\nTokenization\\nIn the previous paragraph, we have adopted an extremely crude definition of a 'word', namely as a string of characters that doesn't contain any whitespace. There are of course many problems that arise if we use such a naive definition. Can you think of some?\\nIn computer science, and computational linguistics in particular, people have come up with much smarter ways to divide texts into words. This process is called tokenization, which refers to the fact that this process divides strings of characters into a list of more meaningful tokens. One interesting package which we can use for this, is nltk (the Natural Language Toolkit), a package which has been specifically designed to deal with language problems. First, we have to import it, since it isn't part of the standard library of Python:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport nltk\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Average Every 15 Mins Hour 2-3 After ROP Exam\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint result3\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"## create a baba object linked to a data file and newick tree\\nbb = ipa.baba(data=locifile, newick=newick)\\n\\n## generate all possible abba-baba tests meeting a set of constraints\\nbb.generate_tests_from_tree(\\n    constraint_dict={\\n        \\\"p4\\\": [\\\"32082_przewalskii\\\", \\\"33588_przewalskii\\\"],\\n        \\\"p3\\\": [\\\"33413_thamno\\\"],\\n    })\\n\\n## run all tests linked to bb \\nbb.run(ipyclient)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nShort tutorial: calculating abba-baba statistics\\nTo give a gist of what this code can do, here is a quick tutorial version, each step of which we explain in greater detail below. We first create a 'baba' analysis object that is linked to our data file, in this example we name the variable bb. Then we tell it which tests to perform, here by automatically generating a number of tests using the generate_tests_from_tree() function. And finally, we calculate the results and plot them.\",\"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_Ensemble_Learning.ipynb\\\".\\nThe first task is:\\nCalculate a boolean array whether the predicted classes for the images are correct.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef correct_prediction(images, labels, cls_true):\\n    # Calculate the predicted labels.\\n    pred_labels = predict_labels(images=images)\\n\\n    # Calculate the predicted class-number for each image.\\n    cls_pred = np.argmax(pred_labels, axis=1)\\n\\n    # Create a boolean array whether each image is correctly classified.\\n    correct = (cls_true == cls_pred)\\n\\n    return correct\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\".. sidebar:: The middle column of the Events array\\nMNE-Python events are actually *three* values: in between the sample\\nnumber and the integer event code is a value indicating what the event\\ncode was on the immediately preceding sample. In practice, that value is\\nalmost always `0`, but it can be used to detect the *endpoint* of an\\nevent whose duration is longer than one sample. See the documentation of\\n:func:`mne.find_events` for more details.\\n\\nIf you don't provide the name of a STIM channel, :func:~mne.find_events\\nwill first look for MNE-Python config variables &lt;tut-configure-mne&gt;\\nfor variables MNE_STIM_CHANNEL, MNE_STIM_CHANNEL_1, etc. If those are\\nnot found, channels STI 014 and STI101 are tried, followed by the\\nfirst channel with type \\\"STIM\\\" present in raw.ch_names. If you regularly\\nwork with data from several different MEG systems with different STIM channel\\nnames, setting the MNE_STIM_CHANNEL config variable may not be very\\nuseful, but for researchers whose data is all from a single system it can be\\na time-saver to configure that variable once and then forget about it.\\n:func:~mne.find_events has several options, including options for aligning\\nevents to the onset or offset of the STIM channel pulses, setting the minimum\\npulse duration, and handling of consecutive pulses (with no return to zero\\nbetween them). For example, you can effectively encode event duration by\\npassing output='step' to :func:mne.find_events; see the documentation\\nof :func:~mne.find_events for details. More information on working with\\nevents arrays (including how to plot, combine, load, and save event arrays)\\ncan be found in the tutorial tut-event-arrays.\\nReading embedded events as Annotations\\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\nSome EEG\\/MEG systems generate files where events are stored in a separate\\ndata array rather than as pulses on one or more STIM channels. For example,\\nthe EEGLAB format stores events as a collection of arrays in the :file:.set\\nfile. When reading those files, MNE-Python will automatically convert...\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntesting_data_folder = mne.datasets.testing.data_path()\\neeglab_raw_file = os.path.join(testing_data_folder, 'EEGLAB', 'test_raw.set')\\neeglab_raw = mne.io.read_raw_eeglab(eeglab_raw_file)\\nprint(eeglab_raw.annotations)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Finance-Banking-Related\\/Lending Club Loan Data - Exploratory Data Analysis [Part I, Python notebook, kaggle].ipynb\\\".\\nThe first task is:\\nF1. Nominal Categorical Attributes\\nWe chose to define as nominal categorical attributes the variables below:\\n\\n'home_ownership': The home ownership status provided by the borrower during registration (Values: 'ANY', 'MORTGAGE', 'NONE', 'OTHER', 'OWN', 'RENT').\\n'pymnt_plan': Indicates if a payment plan has been put in place for the loan (Values: 'y'\\/'n').\\n'purpose': A category provided by the borrower for the loan request (Values: 'car', 'credit_card', 'debt_consolidation', 'educational', ..., 'renewable_energy', 'small_business', 'vacation', 'wedding').\\n'zip_code': The first 3 numbers of the zip code provided by the borrower in the loan application (Values: US Zip Codes).\\n'addr_state': The state provided by the borrower in the loan application (Values: US State Name).\\n'initial_list_status': The initial listing status of the loan (Values: 'w'\\/'f').\\n'policy_code': Publicly available products ('policy_code'='1'), New products not publicly available ('policy_code'='2').\\n'application_type': Indicates whether the loan is an individual application or a joint application with two co-borrowers (Values: 'INDIVIDUAL'\\/'JOINT').\\n\\nAmong them, these two cannot be important for the response variable outcome, 'loan_status':\\n\\n'pymnt_plan' (having only 10 'y' values, and all the remaining ones being 'n')\\n'policy_code' (there are no products which are not publicly available, i.e. 'policy code': '2')\\n\\nNote, that the 'application_type' attribute which indicates whether a loan is an individual or a joint application \\nhas only 511 'JOINT' applications, whereas all the remaining ones (886868!) have been made by individuals. However, we choose to keep this variable for the time being, and check below if the response variable appears any difference among the two types of loans.\\nCan you write Python code for it?\\n\",\"targets\":\"\\npprint(nominal_categ_attribs)\\n\\ncateg_df[nominal_categ_attribs].info()\\n\\nfor attrib in nominal_categ_attribs:\\n    s = 'Nominal Categorical Attribute: \\\"%s\\\":' % attrib\\n    print(s)\\n    print('-' * (len(s)+3))\\n    pprint(categ_df.loc[:3, attrib])\\n    s = '\\\\nValue Counts:'\\n    print(s)\\n    print('-' * (len(s)+3))\\n    pprint(pd.value_counts(categ_df[attrib]))\\n    print('\\\\n')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<h3> SELECTION DOWNLOAD <\\/h3>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfor nc in selected_netCDFs:\\n    last_idx_slash = file_name.rfind('\\/')\\n    ncdf_file_name = file_name[last_idx_slash+1:]\\n    folders = file_name.split('\\/')[3:len(file_name.split('\\/'))-1]\\n    host = file_name.split('\\/')[2] #distribution unit\\n    \\n    ftp=ftplib.FTP(host,user,password) \\n    for folder in folders:\\n    ftp.cwd(folder)\\n    \\n    local_file = open(ncdf_file_name, 'wb')\\n    ftp.retrbinary('RETR '+ncdf_file_name, local_file.write)\\n    local_file.close()\\n    ftp.quit()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create a dashboard with Data Studio\\nFollow the steps in this section to create an interactive, shareable dashboard of the forecasted data by using Data Studio. \\nCreate a view containing the data for the dashboard\\nCreate a view that concatenates the historical and forecasted data. The SQL before the UNION ALL clause selects the historical data. The SQL after the UNION ALL clause uses ML.FORECAST to generate the forecasted value and the prediction interval. The query uses different fields for history_value and forecasted_value so that you can plot them in different colors in a following step.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%%bigquery --params $ARIMA_PARAMS  --project $PROJECT_ID \\n\\nCREATE OR REPLACE VIEW bqmlforecast.outputdata_datastudio AS (\\n  SELECT\\n    date AS timestamp,\\n    item_name,\\n    total_amount_sold AS history_value,\\n    NULL AS forecast_value,\\n    NULL AS prediction_interval_lower_bound,\\n    NULL AS prediction_interval_upper_bound\\n  FROM\\n    bqmlforecast.training_data\\n  UNION ALL\\n  SELECT\\n    EXTRACT(DATE\\n    FROM\\n      forecast_timestamp) AS timestamp,\\n    item_name,\\n    NULL AS history_value,\\n    forecast_value,\\n    prediction_interval_lower_bound,\\n    prediction_interval_upper_bound\\n  FROM\\n    ML.FORECAST(MODEL bqmlforecast.arima_model,\\n      STRUCT(30 AS horizon, 0.9 AS confidence_level)) \\n  ORDER BY timestamp\\n  )\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Assign a Series to a column (note if assigning a list or array, the length must match the DataFrame, unlike a Series):\\n\",\"targets\":\"unempl = pd.Series([6.0, 6.0, 6.1], index=[2, 3, 4])\\ndf_3['unempl'] = unempl\\ndf_3\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"LP\\/Introduction-to-linear-programming\\/Introduction to Linear Programming with Python - Part 5.ipynb\\\".\\nThe first task is:\\nLet's take a look at the optimal production schedule output for each month from each factory. For ease of viewing we'll output the data to a pandas DataFrame.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nx=production[1, 'A']\\ntype(x)\\n\\noutput = []\\nfor month, factory in production:\\n    var_output = {\\n        'Month': month,\\n        'Factory': factory,\\n        'Production': production[(month, factory)].varValue,\\n        'Factory Status': factory_status[(month, factory)].varValue\\n    }\\n    output.append(var_output)\\noutput_df = pd.DataFrame.from_records(output).sort_values(['Month', 'Factory'])\\noutput_df.set_index(['Month', 'Factory'], inplace=True)\\noutput_df\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Example 1, numerically.\\ndef f_SIR(t,y,alpha,beta):\\n    S = y[0]\\n    I = y[1]\\n    R = y[2]\\n    \\n    Sp = -alpha*I*S\\n    Ip = alpha*I*S-beta*I\\n    Rp = beta*I\\n    \\n    return np.array([Sp,Ip,Rp])\\n\\n# Initial condition\\nN = 1e6\\nalpha = 1e-6\\nbeta = 1\\/3\\n\\nS0 = 9e5\\nI0 = 1e5\\ny0 = np.array([S0, I0, N-S0-I0])\\n\\nT = 20\\n\\n# time where we want your solution\\nt = np.linspace(0, T, 100)\\nsol = solve_ivp(f_SIR, [0,T], y0, t_eval=t, args=(alpha,beta))\\n\\nplt.figure()\\nplt.plot(t, sol.y[0], 'b', label='S(t)')\\nplt.plot(t, sol.y[1], 'r', label='I(t)')\\nplt.plot(t, sol.y[2], 'g', label='R(t)')\\nplt.legend(loc='right', bbox_to_anchor=(1.3, 0.5))\\nplt.xlabel('t')\\nplt.ylabel('number of individuals')\\nplt.grid(True)\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n2.2.2.- SIR models in epidemiology\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Astropy tables\\nThere is great deal of flexibility in the way that a table can be initially constructed:\\n\\nRead an existing table from a file or web URL\\nAdd columns of data one by one\\nAdd rows of data one by one\\n\\nFrom an existing data structure in memory:\\n\\n\\nList of data columns\\n\\nDict of data columns\\nList of row dicts\\nNumpy homgeneous array or structured array\\nList of row records\\n\\nSee the documentation section on Constructing a table for the gory details and plenty of examples.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nt = Table()\\nt['name'] = ['larry', 'curly', 'moe', 'shemp']\\nt['flux'] = [1.2, 2.2, 3.1, 4.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 \\\"Heteroscedasticity.ipynb\\\".\\nThe first task is:\\nP値は0.003より有意水準1%でも帰無仮説BP=0を棄却することができ、不均一分散であると結論することができます。\\n例題6-3\\n「k0602.csv」を用いた不均一分散のデータである場合の回帰分析。\\n不均一分散が存在する場合、変数を対数化することによって不均一分散の状態の解消を行います。\\n先ほど読み込んだ「k0602.csv」のデータから変数の対数化を行います。\\ndataの中に新しいコラム「lnX」「lnY」を追加します。\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndata[\\\"lnX\\\"] = np.log(data[\\\"X\\\"])\\ndata[\\\"lnY\\\"] = np.log(data[\\\"Y\\\"])\\ndata\\n\\n# 説明変数設定\\nX = data['lnX']\\nX = sm.add_constant(X)\\nX\\n\\n# 被説明変数設定\\nY = data['lnY']\\nY\\n\\n# OLSの実行(Ordinary Least Squares: 最小二乗法)\\nmodel = sm.OLS(Y,X)\\nresults = model.fit()\\nprint(results.summary())\\n# グラフ生成\\nplt.plot(data[\\\"lnX\\\"], data[\\\"lnY\\\"], 'o', label=\\\"data\\\")\\nplt.plot(data[\\\"lnX\\\"], results.fittedvalues, label=\\\"OLS\\\")\\nplt.xlim(min(data[\\\"lnX\\\"])-0.5, max(data[\\\"lnX\\\"])+0.5)\\nplt.ylim(min(data[\\\"lnY\\\"])-0.5, max(data[\\\"lnY\\\"])+0.5)\\nplt.title('Example6-3')\\nplt.legend(loc=2)\\nplt.show()\\n\\n# BPテスト\\nBP = smsdia.het_breushpagan(results.resid, results.model.exog)\\nprint('Breusch-Pagan test : ')\\nprint('BP = ', BP[0])\\nprint('p-value = ', BP[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 \\\"31_ML-IV\\/ML_4.ipynb\\\".\\nThe first task is:\\nHomework\\nTraining Your Final Classifiers!\\nOnce you have parameters that you're happy with for each dataset, go ahead and make one final classifier. You must set the random state, and your code must produce a classifier named d1_classifier for the disease 1 dataset and d2_classifier from the disease two dataset. Each one should assume that data have been loaded into variables named X1 and X2 respectively for features, and y1 and y2 for labels. You can assume that these have already been loaded (just like we did above). You don't have to report everything you try below, but include the training score and testing score (using classifier.score) and accuracy + 2x standard deviation from cross validation (as in prelab) for your final classifiers.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# CODE TO CREATE THE d1_classifier\\n\\n# CODE TO CREATE THE d2_classifier\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# we can unfreeze and this will train the entire network\\nlearn.unfreeze()\\n# bn_freeze stops updates of \\nlearn.bn_freeze(True) # important for large models --> stops updates of BN moving avgs\\n                      # use for models w\\/ ~ > 34 layers, & larger imgs & reg.s of intrst & norml imgs\\n%time learn.fit([1e-5, 1e-4, 1e-2], 1, cycle_len=1)\\n\\n# We use Test Time Augmentation to ensure we get the best predictions we can\\n%time log_preds, y = learn.TTA()\\n\\n# Finally, this gives us about 99.6% accuracy\\nmetrics.log_loss(y, np.exp(log_preds)), accuracy(log_preds, y)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe didn't specify precompute=True because it only makes it a little faster for this first set. So we skipped it. It's a shortcut that caches some of the intermediate steps that don't have to be recalculated each time. NOTE: when we use precomputed activations: data augmentation will not work.\\nSo if you specfy data augmentation, such as w\\/ aug_tfms=..., and also precompute=True fastai will not actually do any data augmentation.\\nNOTE: if you're using big \\/ deep model like ResNet50 or ResNeXt101 on a dataset v.similar to ImageNet (like this cats\\/dogs datset; ie: side-on photos of standard objects of a similar size to ImageNet: 200~500 pxls), you should probably run learn.bn_freeze(True) after learn.unfreeze().\\nWhat this is doing is causing the BatchNorm moving averages to stop updating.\\n(Not currently supported by any library besides fastai, and is v.important)\\nNeeded to restart kernel & set batch-size to 16 to fit it in Gfx Memory\\nrerun lines: tfms = ...; data = ...; learn = ...;\\nWe run one more epoch, training the entire network:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"As you can see, the chunkshape has been changed, which has also affected the memory size of the compressed data array. We have indeed reduced the number of chunks in the dataset, which reduces the number of data to store. This modification can also improve or deteriorate the I\\/O speed of access to your data array in the dataset. The reader is once again refered to dedicated documents to know more ion this matter: here and here.\\nCompression data and setting chunkshape upon creation of data items\\nUntil here we have only modified the compression settings of already existing data items. In this process, the data items are replaced by the new compressed version of the data, which is a costly operation. For this reason, if they are known in advance, it is best to apply the compression filters and appropriate chunkshape when creating the data item.\\nIf you have read through all the tutorials of this user guide, you should know all the method that allow to create data items in your datasets, like add_data_array, add_field, ædd_mesh... All of these methods accept the two arguments chunkshape and compression_options, that work exaclty as for the set_chunkshape_and_compression or set_nodes_compression_chunkshape methods. You hence use them to create your data items directly with the appropriate compression settings.\\nLet us see an example. We will get an array from our dataset, and try to recreate it with a new name and some data compression:\\n\",\"targets\":\"# removing dataset to recreate a copy\\ndel data\\n# creating a copy of the dataset to try out lossy compression methods\\ndata = SD.copy_sample(src_sample_file=dataset_file, dst_sample_file='Test_compression', autodelete=True,\\n                      get_object=True, overwrite=True)\\n\\n# getting the `orientation_map` array\\narray = data['Amitex_stress_1']\\n\\n# create a new field for the CellData image group with the `orientation_map` array and add compression settings\\ncompression_options = {'complib':'zlib', 'complevel':1, 'shuffle':True,  'least_significant_digit':2,\\n                       'normalization':'standard'}\\nnew_cshape = (10,10,10,3)\\n\\n# Add data array as field of the CellData Image Group\\ndata.add_field(gridname='CellData', fieldname='test_compression', indexname='testC', array=array,\\n              chunkshape=new_cshape, compression_options=compression_options, replace=True)\\n\\n# Check size and settings of new field\\ndata.print_node_info('testC')\\ndata.get_node_disk_size('testC')\\ndata.print_node_compression_info('testC')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"A behaviour profile looks like a nested list.  Entries are of the form profile[player][infoset][action].\\n\",\"targets\":\"result[0]\\n\\nresult[0][g.players[\\\"Alice\\\"]]\\n\\nresult[0][g.players[\\\"Bob\\\"]]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%writefile Snakefile\\nrule all:\\n    input: expand('original_data\\/dataset{id}.nix', id=range(10))\\n        \\nrule generate_data:\\n    output: 'original_data\\/dataset{id,[0-9]}.nix'\\n    shell: 'python generate_poisson.py {output}'\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe first rule in the workflow knows how to utilize the script to generate 10 new datasets. We limit the ids of the generated datasets from 0 to 9 to be able to use higher ids for different datasets.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<a name=\\\"kaggle\\\"><\\/a>\\nKaggle Challenge Data\\nThe Otto Group is one of the world’s biggest e-commerce companies, A consistent analysis of the performance of products is crucial. However, due to diverse global infrastructure, many identical products get classified differently.\\nFor this competition, we have provided a dataset with 93 features for more than 200,000 products. The objective is to build a predictive model which is able to distinguish between our main product categories. \\nEach row corresponds to a single product. There are a total of 93 numerical features, which represent counts of different events. All features have been obfuscated and will not be defined any further.\\nhttps:\\/\\/www.kaggle.com\\/c\\/otto-group-product-classification-challenge\\/data\\nFor this section we will use the Kaggle Otto Group Challenge Data. You will find these data in\\ndata\\/kaggle_ottogroup\\/ folder.\\nLogistic Regression\\nThis algorithm has nothing to do with the canonical linear regression, but it is an algorithm that allows us to solve problems of classification(supervised learning). \\nIn fact, to estimate the dependent variable, now we make use of the so-called logistic function or sigmoid. \\nIt is precisely because of this feature we call this algorithm logistic regression.\\n\\nData Preparation\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom kaggle_data import load_data, preprocess_data, preprocess_labels\\n\\nX_train, labels = load_data('data\\/kaggle_ottogroup\\/train.csv', train=True)\\nX_train, scaler = preprocess_data(X_train)\\nY_train, encoder = preprocess_labels(labels)\\n\\nX_test, ids = load_data('data\\/kaggle_ottogroup\\/test.csv', train=False)\\n\\nX_test, _ = preprocess_data(X_test, scaler)\\n\\nnb_classes = Y_train.shape[1]\\nprint(nb_classes, 'classes')\\n\\ndims = X_train.shape[1]\\nprint(dims, 'dims')\\n\\nnp.unique(labels)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# 创建元组，用小括号\\n\\nt = ('Tom', 'Jerry', 'Mary')\\nprint(t)\\n\\n# 访问元组的元素\\n\\nprint(t[1])\\n\\n# 元组创建后是不能修改的\\n\\n# 会报错\\nt.append('Someone')\\n\\n# 元组创建后是不能修改的\\n\\n# 像列表一样去定义值也会报错\\n# 'tuple' object does not support item assignment\\nt[1] = 'aaa'\\n\\n# 看看 tuple 有什么方法，你会发现很少\\n\\nprint(dir(tuple))\\n\\n# 创建复杂一点的元组\\n\\nt1  = ['A', 'B', 'C']\\nt2 =(t1, 100, 200)\\nprint(t2)\\n\\n# 变通的实现\\\"可变\\\"元组内容\\n\\nt1  = ['A', 'B', 'C']\\nt2 =(t1, 100, 200)\\nprint(t1)\\nprint(t2)\\n\\n# tuple的每个元素，指向永远不变，但指向的元素本身是可变的\\nt1.append('D')\\n\\nprint(t1)\\nprint(t2)  \\n\\n# 创建只有1个元素的元组\\n\\n# 下面这样是不行的\\nt = (1)\\n# l成了一个整数，因为这里的括号有歧义，被认作数学计算里的小括号\\nprint(type(t))  \\n\\n# 1个元素的元组必须加逗号来消除歧义\\nt = (1,)\\nprint(type(t))\\nprint(t)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n元组Tuple 用法\\nTuple 也是一种有序列表，在存储数据方面和列表很相似，为了区分，我们叫它元组。\\nTuple 一旦内容存储后，就不能修改；这样的好处是数据很安全。\\n应用范围：在我们需要使用列表功能的时候，但是又不需要改变这个列表的内容，用元组 Tuple 功能会很安全，不用担心程序中不小心修改了其内容。Python 在向函数传递多个参数的时候，就是采用元组，保证参数在被调用的过程中的安全。\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Code Block 7\\n\\nfor i in range(nt):\\n    mg[\\\"node\\\"][\\\"topographic__elevation\\\"][mg.core_nodes] += uplift_per_step\\n    lin_diffuse.run_one_step(dt)\\n    time_counter += dt\\n\\n    # All landscape evolution is the first two lines of loop.\\n    # Below is simply for plotting the topography halfway through the run\\n    if i == int(nt \\/\\/ 2):\\n        figure(1)\\n        imshow_grid(mg, \\\"topographic__elevation\\\")\\n        title(\\\"topography at time %s, with D = %s\\\" % (time_counter, D))\\n        figure(2)\\n        elev_rast = mg.node_vector_to_raster(mg.at_node[\\\"topographic__elevation\\\"])\\n        plot(ys_grid, elev_rast[:, 2], \\\"k-\\\", label=\\\"model\\\")\\n        plot(ys, zs, \\\"g--\\\", label=\\\"analytical solution - SS\\\")\\n        plot(ys, zs * 0.75, \\\"b--\\\", label=\\\"75% of analytical solution\\\")\\n        plot(ys, zs * 0.5, \\\"r--\\\", label=\\\"50% of analytical solution\\\")\\n        xlabel(\\\"horizontal distance (m)\\\")\\n        ylabel(\\\"vertical distance (m)\\\")\\n        legend(loc=\\\"lower center\\\")\\n        title(\\\"topographic__elevation at time %s, with D = %s\\\" % (time_counter, D))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow we are ready to evolve the landscape and compare it to the steady state solution.\\nBelow is the time loop that does all the calculations.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Below I'm running images through the VGG network in batches.\\n\",\"targets\":\"# Set the batch size higher if you can fit in in your GPU memory\\nbatch_size = 100\\ncodes_list = []\\nlabels = []\\nbatch = []\\n\\ncodes = None\\nvgg = vgg16.Vgg16()\\ninput_ = tf.placeholder(tf.float32, [None, 224, 224, 3])\\nwith tf.name_scope(\\\"content_vgg\\\"):\\n    vgg.build(input_)\\n        \\n\\nwith tf.Session() as sess:\\n    for each in classes:\\n        print(\\\"Starting {} images\\\".format(each))\\n        class_path = data_dir + each\\n        files = os.listdir(class_path)\\n        for ii, file in enumerate(files, 1):\\n            # Add images to the current batch\\n            # utils.load_image crops the input images for us, from the center\\n            img = utils.load_image(os.path.join(class_path, file))\\n            batch.append(img.reshape((1, 224, 224, 3)))\\n            labels.append(each)\\n            \\n            # Running the batch through the network to get the codes\\n            if ii % batch_size == 0 or ii == len(files):\\n                \\n                # Image batch to pass to VGG network\\n                images = np.concatenate(batch)\\n                \\n                feed_dict = {input_: images}\\n                codes_batch =  sess.run(vgg.relu6, feed_dict=feed_dict)\\n                \\n                # Here I'm building an array of the codes\\n                if codes is None:\\n                    codes = codes_batch\\n                else:\\n                    codes = np.concatenate((codes, codes_batch))\\n                \\n                # Reset to start building the next batch\\n                batch = []\\n                print('{} images processed'.format(ii))\\n\\n# write codes to file\\nwith open('codes', 'w') as f:\\n    codes.tofile(f)\\n    \\n# write labels to file\\nimport csv\\nwith open('labels', 'w') as f:\\n    writer = csv.writer(f, delimiter='\\\\n')\\n    writer.writerow(labels)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Aplicação do PageRank na Base da Dados Real\\nApós o teste, vamos aplicar o algoritmo de PageRank na base de dados de referências de páginas da web (arquivo web-Google.txt) encontrada no site da Stanford.\\n\",\"targets\":\"diretorio_base = os.path.join('data')\\ncaminho = os.path.join('web-Google.txt')\\narquivo = os.path.join(diretorio_base, caminho)\\n\\nlinksGoogle = sc.textFile(arquivo).filter(lambda x: \\\"#\\\" not in x).map(lambda x: x.split(\\\"\\\\t\\\"))\\n\\nlinksAgrupados = linksGoogle.groupByKey().cache()\\n\\nranks = linksAgrupados.map(lambda url_agrupados: (url_agrupados[0], 1.0))\\n\\nfor x in range(1,8):\\n    # Adiciona ranks inicializados com 1.0 na posição [1][1] da matriz\\n    agrupaIdLinkComRank = linksAgrupados.join(ranks)\\\\\\n                .flatMap(lambda url_rank: atualizaRank(url_rank[1][0], url_rank[1][1]))\\n    # Soma os valores com o mesmo id e adiciona o fator de normalização\\n    ranks = agrupaIdLinkComRank.reduceByKey(add)\\\\\\n                                .mapValues(lambda rankFatorD: (rankFatorD * 0.85) + 0.15)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Data Visualization\\/Seaborn\\/Seaborn Practice - Titanic Data.ipynb\\\".\\nThe first task is:\\nTwo histograms ploted using FacetGrid based on age and  sex\\nCan you write Python code for it?\\n\",\"targets\":\"\\ng = sns.FacetGrid(data=titanic,col='sex')\\ng.map(plt.hist,'age')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<a href=\\\"http:\\/\\/spark.apache.org\\/docs\\/1.2.0\\/api\\/python\\/pyspark.html#pyspark.RDD.sample\\\">\\n<img align=left src=\\\"files\\/images\\/pyspark-page10.svg\\\" width=500 height=500 \\/>\\n<\\/a>\\n\",\"targets\":\"# sample\\nx = sc.parallelize(range(7))\\nylist = [x.sample(withReplacement=False, fraction=0.5) for i in range(5)] # call 'sample' 5 times\\nprint('x = ' + str(x.collect()))\\nfor cnt,y in zip(range(len(ylist)), ylist):\\n    print('sample:' + str(cnt) + ' y = ' +  str(y.collect()))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Apply Imputer\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Apply the imputer to the df dataset\\nimputed_df = mean_imputer.transform(df.values)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<hr \\/>\\nSystematic shifts we're going to study:\\n\",\"targets\":\"cfg.add_shift(\\\"nominal\\\", 1)\\ncfg.add_shift(\\\"lumi_up\\\", 2, type=\\\"rate\\\")\\ncfg.add_shift(\\\"lumi_down\\\", 3, type=\\\"rate\\\")\\ncfg.add_shift(\\\"scale_up\\\", 4, type=\\\"shape\\\")\\ncfg.add_shift(\\\"scale_down\\\", 5, type=\\\"shape\\\")\\nprint(len(cfg.shifts))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"According to this analysis, Pedro Martinez is the highest paid Hall of Famer of all time.\\n4. Who is the lowest paid Hall of Famer of all-time?\\nI'll conclude by showing the lowest paid Hall of Famer of all-time by both metrics. I'll keep K fixed at 10 for brevity's sake.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfor key in sorted(d_larg,key=d_larg.get)[:5]:\\n    print key,' '.join(pid_to_name[key]),d_larg[key]\\n\\nfor key in sorted(d_ave,key=d_ave.get)[:5]:\\n    print key,' '.join(pid_to_name[key]),d_ave[key]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#reload(pynoddy.output)\\ngeophys = pynoddy.output.NoddyGeophysics(output)\\n\\ngeophys.grv_data\\n\\n\\nfig = plt.figure(figsize = (5,5))\\nax = fig.add_subplot(111)\\n# imshow(geophys.grv_data, cmap = 'jet')\\n# define contour levels\\nlevels = np.arange(322,344,1)\\ncf = ax.contourf(geophys.grv_data, levels, cmap = 'gray', vmin = 324, vmax = 342)\\ncbar = plt.colorbar(cf, orientation = 'horizontal')\\n# print levels\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe now get two files for the caluclated fields: '.grv' for gravity, and '.mag' for the magnetic field. We can extract the information of these files for visualisation and further processing in python:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create new variable in the dataframe\\nphysicsOnlyDataFrame['AgeAwarded'] = physicsOnlyDataFrame.Year - physicsOnlyDataFrame.BirthYear\\nphysicsOnlyDataFrame.head(5)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe have now successfully plotted the histogram of just the physics prizes after applying our pre-selection.\\nCalculations, Scatter Plots and 2D Histogram\\nAdding New Data to a Data Frame\\nYou will find this section useful for when it comes to creating a Dalitz plot in the particle physics analysis.\\nWe want to see what ages people have been awarded Nobel prizes and measure the spread in the ages.\\nThen we'll consider if over time people have been getting awarded Nobel prizes earlier or later in their life. \\nFirst we'll need to calculate the age or the winners at the time the prize was awarded based on the Year and Birthdate columns. We create an AgeAwarded variable and add this to the data.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"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\":\"<a id=\\\"alos_land_change_load\\\"><\\/a> Load and Clean Data from the Data Cube &#9652;\\n\",\"targets\":\"dataset = dc.load(product = product, platform = platform, \\n                  latitude = lat, longitude = lon, \\n                  time=time_extents)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"6. Generator Functions\\nGenerator functions with yield\\n\",\"targets\":\"def myrange(n):\\n    for i in range(n):\\n        yield i\\n\\nmax(myrange(5))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"$$k_1 + k_2$$ density element is not null\\n\",\"targets\":\"sum=K[1]+K[2]\\nsum.texLabel='k_1+k_2'\\nshowDerivatives(f, 3, sum)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As we have said, the children of node $c$ are at positions $2c + 1$ and $2c + 2$. \\nSo, here is the function that returns the children of a node in the queue.\\nNote that we must be careful to return the right number of children.\\nA node that has children has always two children, except if its only child is the last element of the queue; check the two following examples:\\n```\\n         6                           6                 \\n       \\/   \\\\                       \\/   \\\\               \\n      11    8                     11    8              \\n     \\/ \\\\   \\/ \\\\                   \\/ \\\\   \\/              \\n    17 19 13 12                 17 19 13               \\n[6, 11, 8, 17, 19, 13, 12]  [6, 11, 8, 17, 19, 13] \\n```\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef children(pq, p):\\n    if 2*p + 2 < len(pq):\\n        return [2*p + 1, 2*p + 2]\\n    else:\\n        return [2*p + 1]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Approach 1\\nWe can now use these three time series and estimate the $\\\\epsilon$ values using approach 1. \\nThe functions we can be found in:\\n\\npytesmo.scaling\\npytesmo.metrics\\n\\nWe will use mean-standard deviation scaling. This type of scaling brings the data to the same mean and standard deviation as the reference dataset.\\n\",\"targets\":\"import pytesmo.scaling as scaling\\nimport pytesmo.metrics as metrics\\n\\n# scale to x as the reference\\ny_scaled = scaling.mean_std(y, x)\\nz_scaled = scaling.mean_std(z, x)\\nplt.plot(coord, x, alpha=0.3, label='x')\\nplt.plot(coord, y_scaled, alpha=0.3, label='y scaled')\\nplt.plot(coord, z_scaled, alpha=0.3, label='z scaled')\\nplt.plot(coord, signal, 'k', label='$\\\\Theta$')\\nplt.legend()\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"A dictionary of sources is return that contains pandas DataFrames listing the fluxes and errors of each componenet. \\nNOTE: With proper error propagation, the total error is not always the sqrt of the sum of component errors squared!\\nBayesian fitting\\nNow we will look at the results when a Bayesian fit is performed. \\nWe set our priors and then sample:\\n\",\"targets\":\"pl_bb.K_1.prior = Log_uniform_prior(lower_bound = 1E-1, upper_bound = 1E2)\\npl_bb.index_1.set_uninformative_prior(Uniform_prior)\\n\\npl_bb.K_2.prior = Log_uniform_prior(lower_bound = 1E-6, upper_bound = 1E-3)\\npl_bb.kT_2.prior = Log_uniform_prior(lower_bound = 1E0, upper_bound = 1E4)\\n\\n\\n\\nbayes = BayesianAnalysis(model2,data_list)\\n_=bayes.sample(30,100,500)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#projection of first sample, on to the first PC \\nP11 = np.dot(eig_vecs[:,0], featurematrix_std[0,:]-mean_vec) \\nmlP11 = mlPCA.Y[0,0]\\nSkP11 = SkPC[0,0]\\n\\nP12 = np.dot(eig_vecs[:,1], featurematrix_std[0,:]-mean_vec) \\nmlP12 = mlPCA.Y[0,1]\\nSkP12 = SkPC[0,1]\\n\\nP152 = np.dot(eig_vecs[:,1], featurematrix_std[15,:]-mean_vec) \\nmlP152 = mlPCA.Y[15,1]\\nSkP152 = SkPC[15,1]\\n\\nprint(P11, mlP11, SkP11)\\nprint(P12, mlP12, SkP12)\\nprint(P152, mlP152, SkP152)\\n\\nprint(mlloadings[0,7])\\nprint(eig_vecs[0,7])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCheck that all three give similar results\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2- Upsampling through transposed convolution\\n\\nReverse convolution in which forward and backward passes are swapped\\naka deconvolution\\nDifferentiability retained and training exactly the same as before\\nhttps:\\/\\/dspguru.com\\/dsp\\/faqs\\/multirate\\/interpolation\\/\\nhttps:\\/\\/github.com\\/vdumoulin\\/conv_arithmetic\\n<img src=\\\"https:\\/\\/d17h27t6h515a5.cloudfront.net\\/topher\\/2017\\/October\\/59d8670c_transposed-conv\\/transposed-conv.png\\\">\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef upsample(x):\\n    \\\"\\\"\\\"\\n    Apply a two times upsample on x and return the result.\\n    :x: 4-Rank Tensor\\n    :return: TF Operation\\n    \\\"\\\"\\\"\\n    # TODO: Use `tf.layers.conv2d_transpose`\\n    \\n    return tf.layers.conv2d_transpose(x,\\n                                      x.shape[3],\\n                                      kernel_size=(3, 3),\\n                                      strides=2,\\n                                      padding='SAME')\\n\\n\\nx = tf.constant(np.random.randn(1, 4, 4, 3), dtype=tf.float32)\\nconv = upsample(x)\\n\\nwith tf.Session() as sess:\\n    sess.run(tf.global_variables_initializer())\\n    result = sess.run(conv)\\n\\n    print('Input Shape: {}'.format(x.get_shape()))\\n    print('Output Shape: {}'.format(result.shape))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"3.3 Counting Other Things\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfdist = FreqDist(len(w) for w in text1)\\nfdist\\n\\nprint(fdist.most_common())\\nprint(fdist.max())\\nprint(fdist[3])\\nprint(fdist.freq(3))\\n\\ntricky = sorted(w for w in set(text2) if 'cie' in w or 'cei' in w)\\nfor word in tricky:\\n    print(word, end=' ')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Appendix: stack vs pivot\\nPivot can be implemented by using set_index and unstack.\\n\",\"targets\":\"test = pd.DataFrame({'foo':[\\\"one\\\"] * 3 + [\\\"two\\\"] * 3, 'bar': list(\\\"ABC\\\")*2, 'baz': list(range(6))})\\n\\ntest\\n\\ntest.pivot('foo', 'bar', 'baz')\\n\\ntest.set_index(['foo','bar']).unstack()['baz']\",\"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\":\"\\nQuestion 3 - Training and Testing\\nWhat is the benefit to splitting a dataset into some ratio of training and testing subsets for a learning algorithm?\\nHint: What could go wrong with not having a way to test your model?\\nAnswer:   the importance of split the data randomly, is by splitting the data the bias caused by the entire sample is removed in some way, to validate the quality of the model with the set of test data. And quoting from the course \\\"By separating training and testing sets and graphing performance on each separately, we can get a better idea of how well the model can generalize to unseen data.\\\"\\n\\nAnalyzing Model Performance\\nIn this third section of the project, you'll take a look at several models' learning and testing performances on various subsets of training data. Additionally, you'll investigate one particular algorithm with an increasing 'max_depth' parameter on the full training set to observe how model complexity affects performance. Graphing your model's performance based on varying criteria can be beneficial in the analysis process, such as visualizing behavior that may not have been apparent from the results alone.\\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 region 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<sup>2<\\/sup>, the coefficient of determination.  \\nRun the code cell below and use these graphs to answer the following question.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"... and quickly plotting it via its matplotlib interface is pretty straightforward:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\npl.figure(figsize=(12,7))\\nrrsUnc412.plot.hist(bins=50, range=(0,5e-4), histtype='stepfilled', label='uncertainty at 412nm',\\n                normed=True);\\nrrsUncGreen.plot.hist(bins=50, range=(0,5e-4),histtype='stepfilled', alpha=0.3,\\n                  label='uncertainty at all greenish bands: 510 & 555', normed=True)\\npl.legend();\\npl.title('Histogram of Rrs Uncertainty',fontsize=18);\\npl.ylabel('freq', fontsize=16)\\npl.xlabel(r'$sr^{-1}$', fontsize=16 );\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<span id=\\\"water_detection_with_wofs_extents\\\">Get the Maximum Extents of the Cube &#9652;<\\/span>\\nWith the platform and product, we can get the rest of the metadata. This includes the resolution of a pixel, the latitude\\/longitude extents, and the minimum and maximum dates available of the chosen platform\\/product combination.\\n\",\"targets\":\"full_lat, full_lon, min_max_dates = get_overlapping_area(api, platforms, products)\\n\\nprint(\\\"Available Latitude Extents:\\\", full_lat)\\nprint(\\\"Available Longitude Extents:\\\", full_lon)\\nprint(\\\"Available Time Extents:\\\", np.vectorize(dt_to_str)(min_max_dates))\\n\\ndisplay_map(latitude=full_lat, longitude=full_lon)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Comparision with Stata\\nNote, as indicated, to have comparable results running PCA in Python with other statistical programs, such as Stata, we will want to standardize the data. How do these results compare:\\n```stata\\nimport delimited \\\"iris_download.csv\\\", clear\\npca sepal_len sepal_wid petal_len petal_wid\\nPrincipal components\\/correlation                  Number of obs    =       150\\n                                                  Number of comp.  =         4\\n                                                  Trace            =         4\\n    Rotation: (unrotated = principal)             Rho              =    1.0000\\n--------------------------------------------------------------------------\\n   Component |   Eigenvalue   Difference         Proportion   Cumulative\\n-------------+------------------------------------------------------------\\n       Comp1 |      2.91082       1.9896             0.7277       0.7277\\n       Comp2 |      .921221      .773868             0.2303       0.9580\\n       Comp3 |      .147353      .126746             0.0368       0.9948\\n       Comp4 |     .0206077            .             0.0052       1.0000\\n--------------------------------------------------------------------------\\n\\nPrincipal components (eigenvectors) \\n--------------------------------------------------------------------\\n    Variable |    Comp1     Comp2     Comp3     Comp4 | Unexplained \\n-------------+----------------------------------------+-------------\\n   sepal_len |   0.5224    0.3723   -0.7210   -0.2620 |           0 \\n   sepal_wid |  -0.2634    0.9256    0.2420    0.1241 |           0 \\n   petal_len |   0.5813    0.0211    0.1409    0.8012 |           0 \\n   petal_wid |   0.5656    0.0654    0.6338   -0.5235 |           0 \\n--------------------------------------------------------------------\\n\\n```\\nStandardized PCA Plot\\n\",\"targets\":\"pca_scatter(0, 1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#setup the problem\\nprob = LpProblem('warehouse_routing',LpMinimize)\\n\\n#add the objective\\nprob += objective()\\n\\n#add all the constraints\\nfor c in constraints():\\n    prob+=c\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFinally ready to create the problem, add the objective, and add the constraints\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"3. os模块\\n\",\"targets\":\"import os\\nimport string\\n\\ndef replace(file, search_for, replace_with):\\n    back = os.path.splitext(file)[0] + \\\".bak\\\"\\n    temp = os.path.splitext(file)[0] + \\\".tmp\\\"\\n    \\n    try:\\n        os.remove(temp)\\n    except os.error:\\n        pass\\n    \\n    fi = open(file)\\n    fo = open(temp, \\\"w\\\")\\n    \\n    for s in fi.readlines():\\n        fo.write(string.replace(s, search_for, replace_with))\\n    \\n    fi.close()\\n    fo.close()\\n        \\n    try:\\n        os.remove(back)\\n    except os.error:\\n        pass\\n    \\n    os.rename(file, back)\\n    os.rename(temp, file)\\n\\nfile = \\\"samples\\/sample.txt\\\"\\n\\nreplace(file, \\\"hello\\\", \\\"tjena\\\")\\n\\nreplace(file, \\\"tjena\\\", \\\"hello\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Complete a função pra encontrar o menor (mínimo) valor de uma lista:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef minimo(numeros):\\n    minimo = numeros[0]\\n    for numero in numeros[1:]:\\n        if numero < minimo:\\n            minimo = numero\\n    return minimo\\n\\n# Testes para verificar a corretude da função soma\\nassert minimo([-6473.695, 438.199, 7959.093, 7842.664, 7233.021, -4149.884]) == -6473.695\\nassert minimo([6505.843, -7075.108]) == -7075.108\\nassert minimo([9151.244, -4605.586, -2920.8]) == -4605.586\\nassert minimo([-6586.813, -2264.44, 4460.277]) == -6586.813\\nassert minimo([1553.196, 1631.333]) == 1553.196\\nassert minimo([6876.253, 9349.21, -382.322]) == -382.322\\nassert minimo([9604.147, -378.112, 2574.795, -5597.589, 8751.16]) == -5597.589\\nassert minimo([2761.954, 4439.859, 9361.367, 884.972]) == 884.972\\nassert minimo([2989.882, 346.282, 9051.012, 4973.448, 1821.907]) == 346.282\\nassert minimo([4996.027, -5269.592]) == -5269.592\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Connect to the database\\n\\nWe can use the sqlite3 library to connect to the MIMIC database\\nOnce the connection is established, we'll run a simple SQL query.\\n\",\"targets\":\"# Connect to the MIMIC database\\ntry: \\n    conn = psycopg2.connect(\\\"dbname='mimic' user='tompollard' host='localhost' password='postgres'\\\")\\nexcept: \\n    print('meh')\\n\\n# Create our test query\\ntest_query = \\\"\\\"\\\"\\nSELECT subject_id, hadm_id, admittime, dischtime, diagnosis, admission_type, deathtime, discharge_location\\nFROM mimiciii.admissions;\\n\\\"\\\"\\\"\\n\\n# Run the query and assign the results to a variable\\ntest = pd.read_sql_query(test_query,conn)\\n\\n# Display the first few rows\\ntest\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Import Titanic data (local CSV)\\ntitanic = h2o.import_file(\\\"kaggle_titanic.csv\\\")\\ntitanic.head(5)\\n\\n# Convert 'Survived' and 'Pclass' to categorical values\\ntitanic['Survived'] = titanic['Survived'].asfactor()\\ntitanic['Pclass'] = titanic['Pclass'].asfactor()\\n\\ntitanic['Survived'].table()\\n\\ntitanic['Pclass'].table()\\n\\ntitanic['Sex'].table()\\n\\ntitanic['Age'].hist()\\n\\ntitanic['SibSp'].hist()\\n\\ntitanic['Parch'].hist()\\n\\ntitanic['Fare'].hist()\\n\\ntitanic['Embarked'].table()\\n\\n# Define features (or predictors) manually\\nfeatures = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']\\n\\n# Split the H2O data frame into training\\/test sets\\n# so we can evaluate out-of-bag performance\\ntitanic_split = titanic.split_frame(ratios = [0.8], seed = 1234)\\n\\ntitanic_train = titanic_split[0] # using 80% for training\\ntitanic_test = titanic_split[1]  # using the rest 20% for out-of-bag evaluation\\n\\ntitanic_train.shape\\n\\ntitanic_test.shape\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<br>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<br>\\n<br>\\nNext, we perform an eigendecomposition on the covariance matrix:\\n\",\"targets\":\"cov_mat = np.cov(X_std.T)\\n\\neig_vals, eig_vecs = np.linalg.eig(cov_mat)\\n\\nprint('Eigenvectors \\\\n%s' %eig_vecs)\\nprint('\\\\nEigenvalues \\\\n%s' %eig_vals)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Added linewidth and number of bins arguments.  This should get pushed eventually.\\n\",\"targets\":\"def draw_dist(vec, split=None, ax=None, legend=True, colors=None, lw=2, bins=300):\\n    \\\"\\\"\\\"\\n    Draw a smooth distribution from data with an optional splitting factor.\\n    \\\"\\\"\\\"\\n    _, ax = init_ax(ax)\\n    if split is None:\\n        split = pd.Series('s', index=vec.index)\\n        colors = {'s': colors} if colors is not None else None\\n    for l,v in vec.groupby(split):\\n        if colors is None:\\n            smooth_dist(v, bins=bins).plot(label=l, lw=lw, ax=ax)\\n        else:\\n            smooth_dist(v, bins=bins).plot(label=l, lw=lw, ax=ax, color=colors[l])\\n    if legend and len(split.unique()) > 1:\\n        ax.legend(loc='upper left', frameon=False)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<a id=\\\"watches\\\"><\\/a>\\nControlling what the tape watches\\nThe default behavior is to record all operations after accessing a trainable tf.Variable. The reasons for this are:\\n\\nThe tape needs to know which operations to record in the forward pass to calculate the gradients in the backwards pass.\\nThe tape holds references to intermediate outputs, so you don't want to record unnecessary operations.\\nThe most common use case involves calculating the gradient of a loss with respect to all a model's trainable variables.\\n\\nFor example, the following fails to calculate a gradient because the tf.Tensor is not \\\"watched\\\" by default, and the tf.Variable is not trainable:\\n\",\"targets\":\"# A trainable variable\\nx0 = tf.Variable(3.0, name='x0')\\n# Not trainable\\nx1 = tf.Variable(3.0, name='x1', trainable=False)\\n# Not a Variable: A variable + tensor returns a tensor.\\nx2 = tf.Variable(2.0, name='x2') + 1.0\\n# Not a variable\\nx3 = tf.constant(3.0, name='x3')\\n\\nwith tf.GradientTape() as tape:\\n  y = (x0**2) + (x1**2) + (x2**2)\\n\\ngrad = tape.gradient(y, [x0, x1, x2, x3])\\n\\nfor g in grad:\\n  print(g)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Machine_Learning_in_Python.ipynb\\\".\\nThe first task is:\\nLet's poke around and see what is in the data set.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndata_set.keys()\\n\\ndata_set.data\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# where(condition, value if true, value if false)\\nwhere(population < population.mean('time'), -population, population)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSee with_total for more details and examples.\\nwhere\\nThe where function can be used to apply some computation depending on a condition:\",\"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 3 - Conditions.ipynb\\\".\\nThe first task is:\\nFinally we can use not to test for conditions that are not true.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nif (\\\"z\\\" not in word):\\n    print(\\\"z is not in \\\" + word)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"4\\/CaseStudy4.ipynb\\\".\\nThe first task is:\\nUnpopular Articles\\nAt the very least, we want our software to predict whether an article will be unpopular.  In this case, we define Unpopular as belonging in the bottom 25% in terms of shares amongst articles on a similar platform.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Rank features by importance\\nfeature_selection_model = ExtraTreesClassifier().fit(df[features], df['unpopular'])\\nfeature_importance=feature_selection_model.feature_importances_\\nimportance_matrix=np.array([features,list(feature_importance)]).T\\n\\ndef sortkey(s):\\n    return s[1]\\n\\nsort=zip(features,list(feature_importance))\\n\\n# Extract top 10 important features\\nf = pd.DataFrame(sorted(sort,key=sortkey,reverse=True),columns=['variables','importance'])[:10]\\nf\\n\\nfeatures2=f['variables']\\n\\n#split data into two parts\\nnp.random.seed(0)\\nx_train, x_test, y_train, y_test = train_test_split(df[features2], df.unpopular, test_size=0.4, random_state=None)\\nx_train.shape\\n\\n# Decision Tree accuracy and time elapsed caculation\\n#t0=time()\\n#print \\\"DecisionTree\\\"\\n#dt = DecisionTreeClassifier(min_samples_split=25,random_state=1)\\n#clf_dt=dt.fit(x_train,y_train)\\n#y_predicted_dt = clf_dt.predict(x_test)\\n#t1=time()\\n\\n# Observe how decision tree performed on its own.\\n#print(metrics.classification_report(y_test, y_predicted_dt))\\n#print \\\"time elapsed: \\\", t1-t0\\n\\n# Random Forest \\n\\n# Trainc classifier and time elapsed caculation\\nt2=time()\\n\\nprint \\\"RandomForest\\\"\\nrf = RandomForestClassifier(n_estimators=100,n_jobs=1)\\nclf_rf = rf.fit(x_train,y_train)\\ny_predicted_rf = clf_rf.predict(x_test)\\nt3=time()\\n\\n# See how Random forest performed on its own.\\nprint \\\"Acurracy: \\\", clf_rf.score(x_test,y_test)\\nprint \\\"time elapsed: \\\", t3-t2\\n\\n#KNN\\n\\nfrom sklearn.neighbors import KNeighborsClassifier\\n\\n# Determine K by cross-validation.\\nx_cv_train, x_cv_test, y_cv_train, y_cv_test = train_test_split(x_train, y_train, test_size=0.3, random_state=None)\\n\\n# We use K-values ranging from 1-10\\nk=[5,10,15,20,25,30,35,40,45,50]\\n\\n# Train a model on the training set and use that model to predict on the testing set\\npredicted_knn=[KNeighborsClassifier(n_neighbors=i).fit(x_cv_train,y_cv_train).predict(x_cv_test) for i in k]\\n\\n#Compute accuracy on the testing set for each value of k\\nscore_knn=[metrics.accuracy_score(predicted_knn[i],y_cv_test) for i in range(10)]\\n\\nprint score_knn\\n\\n# Plot...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# variable assignments\\nx = 1.0\\nmy_variable = 12.2\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nVariables and types\\nSymbol names\\nVariable names in Python can contain alphanumerical characters a-z, A-Z, 0-9 and some special characters such as _. Normal variable names must start with a letter. \\nBy convention, variable names start with a lower-case letter, and Class names start with a capital letter. \\nIn addition, there are a number of Python keywords that cannot be used as variable names. These keywords are:\\nand, as, assert, break, class, continue, def, del, elif, else, except, \\nexec, finally, for, from, global, if, import, in, is, lambda, not, or,\\npass, print, raise, return, try, while, with, yield\\n\\nAssignment\\nThe assignment operator in Python is =. Python is a dynamically typed language, so we do not need to specify the type of a variable when we create one.\\nAssigning a value to a new variable creates the variable:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"## Classic output example\\n## Hello World!  \\n\\n## Note that Python 3.X requires parentheses around the arguments passed to the print function.  \\n## Parentheses were not necessary in earlier versions of Python (e.g. 2.7).\\n\\nprint(\\\"Hello World!\\\")\\n\\n## Input example\\n\\nvariable = input('Prompt for input.  Type in anything and hit enter: ')\\nprint( 'Input variable is ' + variable)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSimple Input\\/Output\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As of this writing, the L1 h(t) data has a very large dynamic range at low frequencies. We need to remove this before doing anything.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndata_dt=1.e20*data.astype(float64).detrend()\\nfilt=sig.firwin(int(8*srate)-1,9.\\/nyquist,pass_zero=False,window='hann')\\ndata_hp=fir_filter(data_dt,filt)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"5_root_finding_optimization.ipynb\\\".\\nThe first task is:\\nExample:\\n$$f(x) = x - e^{-x}$$\\n$$f'(x) = 1 + e^{-x}$$\\n$$x_{k+1} = x_k - \\\\frac{f(x_k)}{f'(x_k)} = x_k - \\\\frac{x_k - e^{-x_k}}{1 + e^{-x_k}}$$\\nAsymptotic Convergence of Newton's Method\\nFor a simple root (non-multiplicative) - Let $g(x) = x - \\\\frac{f(x)}{f'(x)}$, then\\n$$x_{k+1} = g(x_k)$$\\nDefinitions of errors and iteration:\\n$$x_{k+1} = x^ + e_{k+1} ~~~~~ x_k = x^ + e_k$$\\nGeneral Taylor expansion:\\n$$x^ + e_{k+1} = g(x^ + e_k) = g(x^) + g'(x^) e_k + \\\\frac{g''(x^*) e_k^2}{2!} + \\\\ldots$$\\nNote that as before $x^$ and $g(x^)$ cancel:\\n$$e_{k+1} = g'(x^) e_k + \\\\frac{g''(x^) e_k^2}{2!} + \\\\ldots$$\\nWhat about $g'(x^*)$ though:\\n$$g'(x) = 1 - \\\\frac{f'(x)}{f'(x)} + \\\\frac{f(x)}{f''(x)}$$\\nwhich simplifies when evaluated at $x = x^*$ to\\n$$g'(x^) = \\\\frac{f(x^)}{f''(x^*)} = 0$$\\nThe expansion then simplifies to \\n$$e_{k+1} = \\\\frac{g''(x^*) e_k^2}{2!} + \\\\ldots$$\\nleading to the conclusion that \\n$$|e_{k+1}| = \\\\left | \\\\frac{g''(x^*)}{2!} \\\\right | |e_k|^2$$\\nNewton's method is therefore quadratically convergent where the the constant is controlled by the second derivative.\\nFor a multiple root (e.g. $f(x) = (x-1)^2$) the case is not particularly rosey unfortunately.\\nExample:\\n$f(x) = \\\\sin (2 \\\\pi x)$\\n$$x_{k+1} = x_k - \\\\frac{\\\\sin (2 \\\\pi x)}{2 \\\\pi \\\\cos (2 \\\\pi x)}= x_k - \\\\frac{1}{2 \\\\pi} \\\\tan (2 \\\\pi x)$$\\nCan you write Python code for it?\\n\",\"targets\":\"\\nx = numpy.linspace(0, 2, 1000)\\nf = lambda x: numpy.sin(2.0 * numpy.pi * x)\\nf_prime = lambda x: 2.0 * numpy.pi * numpy.cos(2.0 * numpy.pi * x)\\n\\nfig = plt.figure()\\naxes = fig.add_subplot(1, 1, 1)\\naxes.plot(x, f(x),'b')\\naxes.plot(x, f_prime(x), 'r')\\naxes.set_xlabel(\\\"x\\\")\\naxes.set_ylabel(\\\"y\\\")\\naxes.set_title(\\\"Comparison of $f(x)$ and $f'(x)$\\\")\\naxes.set_ylim((-2,2))\\naxes.set_xlim((0,2))\\naxes.plot(x, numpy.zeros(x.shape), 'k--')\\n\\nx_k = 0.3\\naxes.plot([x_k, x_k], [0.0, f(x_k)], 'ko')\\naxes.plot([x_k, x_k], [0.0, f(x_k)], 'k--')\\naxes.plot(x, f_prime(x_k) * (x - x_k) + f(x_k), 'k')\\n\\n\\nx_k = x_k - f(x_k) \\/ f_prime(x_k)\\naxes.plot([x_k, x_k], [0.0, f(x_k)], 'ko')\\naxes.plot([x_k, x_k], [0.0, f(x_k)], 'k--')\\n\\nplt.show()\\n\\nx = numpy.linspace(0, 2, 1000)\\nf = lambda x: numpy.sin(2.0 * numpy.pi * x)\\nx_kp = lambda x: x - 1.0 \\/ (2.0 * numpy.pi) * numpy.tan(2.0 * numpy.pi * x)\\n\\nfig = plt.figure()\\naxes = fig.add_subplot(1, 1, 1)\\naxes.plot(x, f(x),'b')\\naxes.plot(x, x_kp(x), 'r')\\naxes.set_xlabel(\\\"x\\\")\\naxes.set_ylabel(\\\"y\\\")\\naxes.set_title(\\\"Comparison of $f(x)$ and $f'(x)$\\\")\\naxes.set_ylim((-2,2))\\naxes.set_xlim((0,2))\\naxes.plot(x, numpy.zeros(x.shape), 'k--')\\n\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#eltelt ido\\nt=[-3.14159265, -2.81089869, -2.48020473, -2.14951076, -1.8188168 ,\\n       -1.48812284, -1.15742887, -0.82673491, -0.49604095, -0.16534698,\\n        0.16534698,  0.49604095,  0.82673491,  1.15742887,  1.48812284,\\n        1.8188168 ,  2.14951076,  2.48020473,  2.81089869,  3.14159265];\\n#megtett ut\\ns=[-0.18917675,  0.30733932,  1.10617134,  0.99301702,  0.26214699,\\n       -0.21526465, -0.99894001, -1.34350261, -1.38845013, -0.00443704,\\n        0.06863757,  0.33781392,  0.75168117,  1.15622707, -0.13737408,\\n       -0.34339706, -1.14117694, -1.0584432 , -0.63149239,  0.43437089];\\n#meresi hiba\\nerr=[0.2, 0.1, 0.1, 0.2, 0.3, 0.1, 0.4, 0.2, 0.4, 0.1, 0.1, \\n     0.4, 0.4, 0.5, 0.1, 0.2, 0.1, 0.2, 0.2, 0.2]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nEgy példa mérés adatgyűjtéssel, illesztéssel és ábra készítéssel\\nInduljunk ki egy mérési adatsorból:\\neltelt idő [s]|megtett út [m]|mérési hiba [m]\\n----------:|--------------:|-------------------:\\n       -3.14159265| -0.18917675|  0.2\\n       -2.81089869|  0.30733932|  0.1\\n       -2.48020473|  1.10617134|  0.1\\n       -2.14951076|  0.99301702|  0.2\\n       -1.8188168 |  0.26214699|  0.3\\n       -1.48812284| -0.21526465|  0.1\\n       -1.15742887| -0.99894001|  0.4\\n       -0.82673491| -1.34350261|  0.2\\n       -0.49604095| -1.38845013|  0.4\\n       -0.16534698| -0.00443704|  0.1\\n        0.16534698|  0.06863757|  0.1\\n        0.49604095|  0.33781392|  0.4\\n        0.82673491|  0.75168117|  0.4\\n        1.15742887|  1.15622707|  0.5\\n        1.48812284| -0.13737408|  0.1\\n        1.8188168 | -0.34339706|  0.2\\n        2.14951076| -1.14117694|  0.1\\n        2.48020473| -1.0584432 |  0.2\\n        2.81089869| -0.63149239|  0.2\\n        3.14159265|  0.43437089|  0.2\\nTöltsük be ezeket az adatokat 3 python tömbbe:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%sql\\n\\n--  Select all\\nSELECT distinct *\\n\\n-- From the criminals table\\nFROM criminals\\n\\n-- Where age is greater than 23\\nWHERE age = 23\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nView Rows Where Age Is 23\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<img src=\\\"images\\/hanford_variables.png\\\">\\n3. Calculate the basic descriptive statistics on the data\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndf.mean()\\n\\ndf.median()\\n\\niqr = df.quantile(q=0.75)- df.quantile(q=0.25)\\niqr\\n\\nUAL= (iqr*1.5) + df.quantile(q=0.75)\\nUAL\\n\\nLAL= df.quantile(q=0.25) - (iqr*1.5)  \\nLAL\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"2DRodFF_1.ipynb\\\".\\nThe first task is:\\nThe result shows that this numerical method does not preserve the Hamiltonian. Therefore, we try now with the implicit midpoint rule, which according to Hairer et al. (2006), p. 247 preserves quadratic invariants\\n$$N_{n+1} = N_n + \\\\frac{h}{4EI} (Q_n + Q_{n+1})(M_n + M_{n+1})$$\\n$$Q_{n+1} = Q_n - \\\\frac{h}{4EI} (N_n + N_{n+1})(M_n + M_{n+1})$$\\n$$M_{n+1} = M_n - \\\\frac{h}{2} (Q_n + Q_{n+1})$$  \\nRearranging and dividing the first equation by the second one yields $N_{n+1}^2 + Q_{n+1}^2 = N_n^2 + Q_n^2$ (preservation of the Casimir). Substituting the third into the first shows the preservation of the Hamiltonian.\\nThe drawback is that we end up with an implicit scheme in which the $n+1$ variables can't be isolated. In the next experiment we will advance each step using scipy.optimize.root non-linear solver.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport scipy.optimize\\n\\ndef implicitMidpoint(Xn1, Xn, h, EI):\\n    f = np.empty(3)\\n    f[0] = Xn1[0] - Xn[0] - h*(Xn[1] + Xn1[1])*(Xn[2] + Xn1[2])\\/4.\\/EI\\n    f[1] = Xn1[1] - Xn[1] + h*(Xn[0] + Xn1[0])*(Xn[2] + Xn1[2])\\/4.\\/EI\\n    f[2] = Xn1[2] - Xn[2] + h*(Xn[1] + Xn1[1])\\/2.\\n    return f\\n\\nsectionForces = []\\nN0 = F3*np.cos(theta0)\\nQ0 = -F3*np.sin(theta0)\\nM0 = 0.\\nsectionForces.append([N0, Q0, M0])\\n\\nnEdges = 50\\nh = 0.1\\n\\nXn = np.array([N0, Q0, M0])\\nfor n1 in range(1, nEdges+1):\\n    eqSystem = lambda Xn1: implicitMidpoint(Xn1, Xn, h, EI) \\n    solution = scipy.optimize.root(eqSystem, Xn)\\n    Xn1 = solution.x\\n    sectionForces.append(Xn1)\\n    Xn = Xn1\\n\\naxialForce = np.array([force[0] for force in sectionForces])\\nshearForce = np.array([force[1] for force in sectionForces])\\nbendingMoment = np.array([force[2] for force in sectionForces])\\nH = bendingMoment**2\\/2\\/EI + axialForce\\n\\nfig = plt.figure(figsize=(9., 9.))\\n\\nax = fig.gca(projection='3d')\\nax.plot(N3, Q3, M3, color='b')\\nax.plot(N3, Q3, -M3, color='b')\\nax.scatter(axialForce, shearForce, bendingMoment, color='r')\\nax.set_xlabel('$N$')\\nax.set_ylabel('$Q$')\\nax.set_zlabel('$M$')\\n\\nfig = plt.figure(figsize=(7., 7.))\\n\\nax = fig.gca()\\nax.plot(np.linspace(0, h*nEdges, nEdges+1), H)\\nax.set_xlabel('$s$')\\nax.set_ylabel('$\\\\mathcal{H}$')\",\"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.\\n{TODO: Adjust wording in the first paragraph to fit your use case - explain how your tutorial uses the Cloud Storage bucket. The example below shows how Vertex AI uses the bucket for training.}\\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.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nBUCKET_NAME = \\\"[your-bucket-name]\\\"  # @param {type:\\\"string\\\"}\\nBUCKET_URI = f\\\"gs:\\/\\/{BUCKET_NAME}\\\"\\n\\nif BUCKET_NAME == \\\"\\\" or BUCKET_NAME is None or BUCKET_NAME == \\\"[your-bucket-name]\\\":\\n    BUCKET_NAME = PROJECT_ID + \\\"aip-\\\" + TIMESTAMP\\n    BUCKET_URI = f\\\"gs:\\/\\/{BUCKET_NAME}\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Construct a smaller box that will fit inside of the aoi_shape\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nx_diff = maxx - minx\\nminx2 = minx + x_diff \\/ 5\\nmaxx2 = maxx - x_diff \\/ 5\\ny_diff = maxy - miny\\nminy2 = miny + y_diff \\/ 5\\nmaxy2 = maxy - y_diff \\/ 5\\nsmaller_box = shapely.geometry.box(minx2, miny2, maxx2, maxy2)\\nprint(smaller_box.bounds)\\nsmaller_box\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%matplotlib inline\\nimport json\\nimport pandas as pd\\nimport matplotlib.pyplot as plt\\n\\ntweets_data_path = '\\/home\\/nipun\\/Downloads\\/Twitter_scrape\\/Twitter_scrape.txt'\\n\\ntweets_data = []\\ntweets_file = open(tweets_data_path, \\\"r\\\")\\nfor line in tweets_file:\\n    try:\\n        tweet = json.loads(line)\\n        tweets_data.append(tweet)\\n    except:\\n        continue\\n        \\nprint len(tweets_data)\\n\\ntweets_df = pd.DataFrame()\\ntweets_df['Username'] = map(lambda tweet: tweet['user']['name'], tweets_data)\\ntweets_df['statuses_count'] = map(lambda tweet: tweet['user']['statuses_count'], tweets_data)\\ntweets_df['friends_count'] = map(lambda tweet: tweet['user']['friends_count'], tweets_data)\\ntweets_df['followers_count'] = map(lambda tweet: tweet['user']['followers_count'], tweets_data)\\ntweets_df['text'] = map(lambda tweet: tweet['text'], tweets_data)\\ntweets_df['lang'] = map(lambda tweet: tweet['lang'], tweets_data)\\ntweets_df['location'] = map(lambda tweet: tweet['user']['location'], tweets_data)\\ntweets_df['created_at'] = map(lambda tweet: tweet['created_at'], tweets_data)\\n\\ntweets_df.dtypes\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nConfigure your python file and write that data inside text file\\nfor storing data<br>\\n$python twitter_streaming.py &gt; twitter_data.txt\\nJSON Format\\n\\nJSON is a syntax for storing and exchanging data.\\nJSON is \\\"self-describing\\\" and easy to understand ( I am not kidding! ) > Let's Visualise it.\\nKey values kind of structure.\\n\\nData preprocessing and cleaning\\n1. Extracting main data from JSON\",\"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\\/More on Python Tools.ipynb\\\".\\nThe first task is:\\nLet's see whether this works for our sin example from above:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nx = linspace(0,2*pi)\\ndsin = nderiv(sin(x),x)\\nplot(x,dsin,label='numerical')\\nplot(x,cos(x),label='analytical')\\ntitle(\\\"Comparison of numerical and analytical derivatives of sin(x)\\\")\\nlegend()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#predict facies of unclassified data\\ny_unknown = gbModel.predict(X_unknown)\\nwell_data['Facies'] = y_unknown\\nwell_data\\n\\nwell_data['Well Name'].unique()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFinally we predict facies labels for the unknown data, and store the results in a Facies column of the test_data dataframe.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2015년 1월 거래가 평균\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nweed_ca_jan2015.mean()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"AutoCSV\\n\",\"targets\":\"# generate a csv from a dataset\\ndef generate_csv(path, labelmap=None, folder='train'):\\n    \\\"\\\"\\\"Infers a csv from directory structure. \\n       `labelmap` is a dictionary mapping class folders to class names.\\n       Class names are taken from class folder names if no mapping is provided.\\n       For Single-Category Classification.\\n    \\\"\\\"\\\"\\n    # find categories\\n    catfolders = [f for f in os.listdir(path\\/folder) if (path\\/folder\\/f).is_dir()]\\n    if labelmap is None: labelmap = {cf:cf for cf in catfolders}\\n\\n    rows = []\\n\\n    for cat in catfolders:\\n        catpath = path\\/folder\\/cat\\n        fpaths  = list(map(lambda x: cat+'\\/'+x, os.listdir(catpath)))\\n        rows.extend(list(zip(fpaths,[labelmap[cat] for i in range(len(fpaths))])))\\n\\n    df = pd.DataFrame(rows, columns=['file','class'])\\n    return df\\n\\n%%time\\ncsv = generate_csv(PATH)\\n\\ncsv.sample(n=10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Chart visualization\\nSome Earth Engine functions produce tabular data that can be plotted by\\ndata visualization packages such as matplotlib. The following example\\ndemonstrates the display of tabular data from Earth Engine as a scatter\\nplot. See Charting in Colaboratory\\nfor more information.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Import the matplotlib.pyplot module.\\nimport matplotlib.pyplot as plt\\n\\n# Fetch a Landsat image.\\nimg = ee.Image('LANDSAT\\/LT05\\/C01\\/T1_SR\\/LT05_034033_20000913')\\n\\n# Select Red and NIR bands, scale them, and sample 500 points.\\nsamp_fc = img.select(['B3','B4']).divide(10000).sample(scale=30, numPixels=500)\\n\\n# Arrange the sample as a list of lists.\\nsamp_dict = samp_fc.reduceColumns(ee.Reducer.toList().repeat(2), ['B3', 'B4'])\\nsamp_list = ee.List(samp_dict.get('list'))\\n\\n# Save server-side ee.List as a client-side Python list.\\nsamp_data = samp_list.getInfo()\\n\\n# Display a scatter plot of Red-NIR sample pairs using matplotlib.\\nplt.scatter(samp_data[0], samp_data[1], alpha=0.2)\\nplt.xlabel('Red', fontsize=12)\\nplt.ylabel('NIR', fontsize=12)\\nplt.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 \\\"NotesDeCours\\/17-exemples.ipynb\\\".\\nThe first task is:\\nOn vérifie que la fonction retourne bien que 4 et 8 ne sont pas des nombres premiers:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n[n for n in range(20) if est_premier(n)]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"(3e) Exercise: Average Number of Daily Requests per Hosts\\nNext, let's determine the average number of requests on a day-by-day basis. We'd like a list by increasing day of the month and the associated average number of requests per host for that day. Make sure you cache the resulting RDD avgDailyReqPerHost so that we can reuse it in the next exercise.\\nTo compute the average number of requests per host, get the total number of request across all hosts and divide that by the number of unique hosts.\\nSince the log only covers a single month, you can skip checking for the month.\\nAlso to keep it simple, when calculating the approximate average use the integer value - you do not need to upcast to float\\n\",\"targets\":\"reqsPerDay = access_logs.map(lambda log: (log.date_time.day, 1)).reduceByKey(lambda a, b: a + b).sortByKey()\\ngroupedByDay = reqsPerDay.join(dailyHosts)\\navgDailyReqPerHost = groupedByDay.map(lambda (day, (r, h)): (day, r \\/ h)).sortByKey().cache()\\navgDailyReqPerHostList = avgDailyReqPerHost.take(30)\\n\\nprint 'Average number of daily requests per Hosts is %s' % avgDailyReqPerHostList\\n\\n# TEST Average number of daily requests per hosts (3e)\\nTest.assertEquals(avgDailyReqPerHostList, [(1, 13), (3, 12), (4, 14), (5, 12), (6, 12), (7, 13), (8, 13), (9, 14), (10, 13), (11, 14), (12, 13), (13, 13), (14, 13), (15, 13), (16, 13), (17, 13), (18, 13), (19, 12), (20, 12), (21, 13), (22, 12)], 'incorrect avgDailyReqPerHostList')\\nTest.assertTrue(avgDailyReqPerHost.is_cached, 'incorrect avgDailyReqPerHost.is_cache')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%bash\\n\\n.\\/foo < numbers.txt\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFeed data via re-direction\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Where am I running?\\n!hostname\\n\\n# How much memory is left on this compute node?\\n!free\\n\\n# On GPU node, you can check the status of the GPU using `nvidia-smi` command:\\n!nvidia-smi\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nStandard UNIX programs can also be run from Jupyter by prepending it with \\\"!\\\".\\nThey better be non-interactive program, not asking for input or output. For example:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# %load _solutions\\/case2_observations_processing26.py\\n\\nlen(unique_species)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<div class=\\\"alert alert-success\\\">\\n\\n**EXERCISE 21**\\n\\n- Extract the unique combinations of genus and species in the `survey_data_plots` using `groupby`. Save the result as the variable `unique_species`.\\n\\n<details><summary>Hints<\\/summary>\\n\\n- As `groupby` needs an aggregation function, this can be `first()` (the first of each group) as well.\\n- Do not forget to `reset_index` after the `groupby`.\\n\\n<\\/details>\\n\\n<\\/div>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Classification and Localisation model\\nThe objective is to build and train a classification and localisation network. This exercise will showcase the flexibility of Deep Learning with several, heterogenous outputs (bounding boxes and classes)\\nWe will build the model in three consecutive steps:\\n- Extract label annotations from a standard Object Detection dataset, namely Pascal VOC 2007;\\n- Use a pre-trained image classification model (namely ResNet50) to precompute convolutional representations with shape (7, 7, 2048) for all the images in the object detection training set;\\n- Design and train a baseline object detection model with two heads to predict: \\n  - class labels (5 possible classes)\\n  - bounding box coordinates of a single detected object in the image\\nNote that the simple baseline model presented in this notebook will only detect a single occurence of a class per image. More work would be required to detect all possible object occurences in the images. See the lecture slides for refernces to state of the art object detection models such as Faster RCNN and YOLO9000.\\nLoading images and annotations\\nWe will be using Pascal VOC 2007, a dataset widely used in detection and segmentation http:\\/\\/host.robots.ox.ac.uk\\/pascal\\/VOC\\/ To lower memory footprint and training time, we'll only use 5 classes: \\\"dog\\\", \\\"cat\\\", \\\"bus\\\", \\\"car\\\", \\\"aeroplane\\\". Here are the first steps:\\n- Load the annotations file from pascalVOC and parse it (xml file)\\n- Keep only the annotations we're interested in, and containing a single object\\n- Pre-compute ResNet conv5c from the corresponding images\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom __future__ import division\\nimport numpy as np\\nimport xml.etree.ElementTree as etree\\nimport os\\nimport os.path as op\\n\\n# Parse the xml annotation file and retrieve the path to each image,\\n# its size and annotations\\ndef extract_xml_annotation(filename):\\n    z = etree.parse(filename)\\n    objects = z.findall(\\\".\\/object\\\")\\n    size = (int(z.find(\\\".\\/\\/width\\\").text), int(z.find(\\\".\\/\\/height\\\").text))\\n    fname = z.find(\\\".\\/filename\\\").text\\n    dicts = [{obj.find(\\\"name\\\").text:[int(obj.find(\\\"bndbox\\/xmin\\\").text), \\n                                     int(obj.find(\\\"bndbox\\/ymin\\\").text), \\n                                     int(obj.find(\\\"bndbox\\/xmax\\\").text), \\n                                     int(obj.find(\\\"bndbox\\/ymax\\\").text)]} \\n             for obj in objects]\\n    return {\\\"size\\\": size, \\\"filename\\\": fname, \\\"objects\\\": dicts}\\n\\n# Filters annotations keeping only those we are interested in\\n# We only keep images in which there is a single item\\nannotations = []\\n\\nfilters = [\\\"dog\\\", \\\"cat\\\", \\\"bus\\\", \\\"car\\\", \\\"aeroplane\\\"]\\nidx2labels = {k: v for k, v in enumerate(filters)}\\nlabels2idx = {v: k for k, v in idx2labels.items()}\\n\\nannotation_folder = \\\"VOCdevkit\\/VOC2007\\/Annotations\\/\\\"\\nfor filename in sorted(os.listdir(annotation_folder)):\\n    annotation = extract_xml_annotation(op.join(annotation_folder, filename))\\n\\n    new_objects = []\\n    for obj in annotation[\\\"objects\\\"]:\\n        # keep only labels we're interested in\\n        if list(obj.keys())[0] in filters:\\n            new_objects.append(obj)\\n\\n    # Keep only if there's a single object in the image\\n    if len(new_objects) == 1:\\n        annotation[\\\"class\\\"] = list(new_objects[0].keys())[0]\\n        annotation[\\\"bbox\\\"] = list(new_objects[0].values())[0]\\n        annotation.pop(\\\"objects\\\")\\n        annotations.append(annotation)\\n\\nprint(\\\"Number of images with annotations:\\\", len(annotations))\\n\\nprint(\\\"Contents of annotation[0]:\\\\n\\\", annotations[0])\\n\\nprint(\\\"Correspondence between indices and labels:\\\\n\\\", idx2labels)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Get your Google Cloud project ID from gcloud\\nshell_output=!gcloud config list --format 'value(core.project)' 2>\\/dev\\/null\\n\\ntry:\\n    PROJECT_ID = shell_output[0]\\nexcept IndexError:\\n    PROJECT_ID = None\\n\\nprint(\\\"Project ID:\\\", PROJECT_ID)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nBefore you begin\\nSet up your Google Cloud project\\nThe following steps are required, regardless of your notebook environment.\\n\\n\\nSelect or create a Google Cloud project. When you first create an account, you get a $300 free credit towards your compute\\/storage costs.\\n\\n\\nMake sure that billing is enabled for your project.\\n\\n\\nEnable the Vertex API.\\n\\n\\nEnable the 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 ! or % as shell commands, and it interpolates Python variables with $ or {} 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.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"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\\n\\nlogger = phoebe.logger()\\n\\nb = phoebe.default_binary()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2) Using this generator to generate a 100nt sequence (as a string)\\n\",\"targets\":\"d = DNA_generator()\\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 \\\"Code\\/notebooks\\/bootcamp_pandas_adv2-shape.ipynb\\\".\\nThe first task is:\\nExercise. Use the dataframe ddts to plot Debt and Surplus across time for Argentina.  Hint: In the plot method, set subplots=True so that each variable is in a separate subplot.  \\nSOL\\n<!--\\nfig, ax = plt.subplots(1, 2, figsize=(12, 4))\\nddts['Argentina']['Surplus'].plot(ax=ax[0])\\nax[0].legend(['Surplus'])\\nddts['Argentina']['Debt'].plot(ax=ax[1])\\nax[1].legend(['Debt'])\\n\\nax[0].axhline(0, color='k')\\nax[0].set_ylim([-10, 10])\\n-->\\n\\nThe xs method\\nAnother approach to extracting data that cuts across levels of the row or column index:  the xs method. This is recent addition to Pandas and an extremely good method once you get the hang of it. \\nThe basic syntax is \\npython\\ndf.xs(item, axis=X, level=N)\\nwhere N is the name or number of an index level and X describes if we are extracting from the index or column names. Setting X=0 (so axis=0) will slice up the data along the index, X=1 extracts data for column labels.\\nHere's how we could use xs to get the Argentina data without swapping the level of the column labels\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# ddt.xs?\\n\\nddt.xs(\\\"Argentina\\\", axis=1, level=\\\"Country\\\")\\n\\nddt.xs(\\\"Argentina\\\", axis=1, level=\\\"Country\\\")[\\\"Debt\\\"]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%bash\\n\\n# TODO 5\\n\\nMODEL_NAME=title_model\\nVERSION_NAME=swivel\\n\\nif [[ $(gcloud ai-platform models list --format='value(name)' | grep ^$MODEL_NAME$) ]]; then\\n    echo \\\"$MODEL_NAME already exists\\\"\\nelse\\n    echo \\\"Creating $MODEL_NAME\\\"\\n    gcloud ai-platform models create --region=$REGION $MODEL_NAME\\nfi\\n\\nif [[ $(gcloud ai-platform versions list --model $MODEL_NAME --format='value(name)' | grep ^$VERSION_NAME$) ]]; then\\n    echo \\\"Deleting already existing $MODEL_NAME:$VERSION_NAME ... \\\"\\n    echo yes | gcloud ai-platform versions delete --model=$MODEL_NAME $VERSION_NAME\\n    echo \\\"Please run this cell again if you don't see a Creating message ... \\\"\\n    sleep 2\\nfi\\n\\necho \\\"Creating $MODEL_NAME:$VERSION_NAME\\\"\\ngcloud ai-platform versions create \\\\\\n  --model=$MODEL_NAME $VERSION_NAME \\\\\\n  --framework=tensorflow \\\\\\n  --python-version=3.7 \\\\\\n  --runtime-version=2.1 \\\\\\n  --origin=$EXPORT_PATH \\\\\\n  --staging-bucket=gs:\\/\\/$BUCKET \\\\\\n  --machine-type n1-standard-4 \\\\\\n  --region=$REGION\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThen we can deploy the model using the gcloud CLI as before:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"!cat ch06\\/ex7.csv\\n\\nimport csv\\nf = open('ch06\\/ex7.csv')\\n\\nreader = csv.reader(f)\\n\\nfor line in reader:\\n    print(line)\\n\\nlines = list(csv.reader(open('ch06\\/ex7.csv')))\\nheader, values = lines[0], lines[1:]\\ndata_dict = {h: v for h, v in zip(header, zip(*values))}\\ndata_dict\\n\\nclass my_dialect(csv.Dialect):\\n    lineterminator = '\\\\n'\\n    delimiter = ';'\\n    quotechar = '\\\"'\\n    quoting = csv.QUOTE_MINIMAL\\n\\nwith open('mydata.csv', 'w') as f:\\n    writer = csv.writer(f, dialect=my_dialect)\\n    writer.writerow(('one', 'two', 'three'))\\n    writer.writerow(('1', '2', '3'))\\n    writer.writerow(('4', '5', '6'))\\n    writer.writerow(('7', '8', '9'))\\n\\n%cat mydata.csv\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nManually working with delimited formats\\nMost forms of tabular data can be loaded from disk using functions like pan das.read_table. In some cases, however, some manual processing may be necessary. It’s not uncommon to receive a file with one or more malformed lines that trip up read_table. To illustrate the basic tools, consider a small CSV file:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"After only 1 epoch, our model is able to acheive about 65% accuracy on testset(If not, try more times).\\nWe can save our model by calling either save or using pickle.\\n\",\"targets\":\"# using pickle\\nimport pickle\\nsmodel = pickle.dumps(model)\\n# using saving (recommended)\\n# We get the benefit being able to directly load\\/save from cloud storage(S3, HDFS)\\nprefix = \\\"cifar10\\\"\\nmodel.save(prefix)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Instanciando\\nlista_eg = [6,10,'Paulo']\\nprint('Os valores do \\\"lista_eg\\\" estão:', lista_eg)\\nprint('O tipo do \\\"lista_eg\\\" está:', type(lista_eg))\\nprint('\\\\n')\\n\\n# Chamando\\nprint('O valor do segundo índice está:', lista_eg[1]) # Nota nas listas de Python o primeiro índice é 0 (não 1)\\nprint('\\\\n')\\n\\n# Substiuindo\\/Mudando os valores \\nlista_eg[1] = lista_eg[1]*4\\nprint('O valor do segundo índice está:', lista_eg[1])\\nprint('\\\\n')\\n\\nlista_eg\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nVariáveis com vários valores\\nAs listas são um tipo de variável com vários valores. \\n\\nEstes tem um conjunto das variávels em uma lista, você busca sobre dando o índice da variável voce quer\\nO índice é um inteiro\\nO valor é qualquer tipo de variável\\nAs listas tem ordem\\nOs valores podem ter tipos das variáveis diferentes em uma lista\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Creating the circuits\\nThe function below creates a Loschmidt echo using a random circuit for $U$ on a given set of qubits for a given number of cycles. A pause can be optionally applied after $U$ and before $U^\\\\dagger$.\\n\",\"targets\":\"def create_loschmidt_echo_circuit(\\n    qubits: Sequence[cirq.GridQubit],\\n    cycles: int,\\n    twoq_gate: cirq.Gate = cirq.FSimGate(np.pi \\/ 4, 0.0),\\n    pause: Optional[cirq.Duration] = None,\\n    seed: Optional[int] = None,\\n) -> cirq.Circuit:\\n    \\\"\\\"\\\"Returns a Loschmidt echo circuit using a random unitary U.\\n    \\n    Args:\\n        qubits: Qubits to use.\\n        cycles: Depth of random rotations in the forward & reverse unitary.\\n        twoq_gate: Two-qubit gate to use.\\n        pause: Optional duration to pause for between U and U^\\\\dagger.\\n        seed: Seed for circuit generation.\\n    \\\"\\\"\\\"\\n    # Forward (U) operations.\\n    forward = random_rotations_between_grid_interaction_layers_circuit(\\n        qubits, \\n        depth=cycles,\\n        two_qubit_op_factory=lambda a, b, _: twoq_gate.on(a, b),\\n        pattern=cirq.experiments.GRID_STAGGERED_PATTERN,\\n        single_qubit_gates=[cirq.PhasedXPowGate(phase_exponent=p, exponent=0.5)\\n                            for p in np.arange(-1.0, 1.0, 0.25)],\\n        seed=seed\\n    )\\n\\n    # Optional pause.\\n    if pause is not None:\\n        wait = cirq.Moment(cirq.WaitGate(pause).on(q) for q in qubits)\\n    else:\\n        wait = []\\n    \\n    # Reverse (U^\\\\dagger) operations.\\n    reverse = cirq.inverse(forward)\\n\\n    # Measure all qubits.\\n    measure = cirq.measure(*qubits, key=\\\"z\\\")\\n\\n    return forward + wait + reverse + measure\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%matplotlib inline\\nimport matplotlib\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\n\\nfirst_500_sm = [float(problem_5(n)) for n in range(1, 501)]\\n\\nfig = plt.figure()\\nax = fig.add_subplot(111)\\nax.set_yscale('log')\\nax.set_title('Smallest Multiple of the x First Numbers, up to 500\\\\n Axes: log-normal\\\\n')\\nax.plot(first_500_sm, color='#348ABD', lw=1.4, alpha=0.6)\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAddendum: Problem 5\\nOut of curiosity, what is the value for the first 500 integers?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Getting Started With Badfish.ipynb\\\".\\nThe first task is:\\nThe pattern plot below gives a nice understanding of the amount of data missing with different combinations of samples. Blue tiles indicate the presence of data whereas red tiles indicate missing data. \\nWe see that Ozone has the highest amount of missing data (27 samples) where-as 8 samples are missing a combination of Ozone and Temp data.\\nNote- The raw counts are given on the left.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmf.plot(kind='pattern', norm = False, threshold=0.0)\\n\\nmf.pattern(columns = ['Ozone', 'Temp', 'Solar.R'], norm = False, threshold=0.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 \\\"02 Variable Strings and Numbers.ipynb\\\".\\nThe first task is:\\nNote\\nThe first instruction of the previous cell is an exmaple of selective module import.\\nSo far, just note that the syntax pattern of the selective import is:\\nfrom module import something[,something else comma separated]\\n\\nSee more about this in the notebook specifically devoted to this!\\n<a name='exercises_numbers'><\\/a>Exercises\\nArithmetic\\n\\nWrite a program that prints out the results of at least one calculation for each of the basic operations: addition, subtraction, multiplication, division, and exponents.\\n\\nOrder of Operations\\n\\nFind a calculation whose result depends on the order of operations.\\nPrint the result of this calculation using the standard order of operations.\\nUse parentheses to force a nonstandard order of operations. Print the result of this calculation.\\n\\nLong Decimals\\n\\nOn paper, 0.1+0.2=0.3. But you have seen that in Python, 0.1+0.2=0.30000000000000004.\\nFind at least one other calculation that results in a long decimal like this.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Ex 2.8 : Arithmetic\\na = 6\\nb = 5\\nprint(\\\"a + b = \\\", end='')\\no = a+b\\nprint(o)\\n\\n# Ex 2.9 : Order of Operations\\nresult = (3*4)+2\\nprint('The result of the calculation of (3*4)+2', result, sep=' = ')\\n\\n# Ex 2.10 : Long Decimals\\nprint(3.125 \\/ 0.2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%bigquery myDataframe\\nWITH MonthlyData AS\\n(\\nSELECT FORMAT_DATE(\\\"%B\\\", taxi_trips.Pickup_DateTime) AS MonthName,\\n       FORMAT_DATE(\\\"%m\\\", taxi_trips.Pickup_DateTime) AS MonthNumber,\\n       CASE WHEN taxi_trips.Payment_Type_Id = 1 THEN 'Credit'\\n            WHEN taxi_trips.Payment_Type_Id = 2 THEN 'Cash'\\n            WHEN taxi_trips.Payment_Type_Id = 3 THEN 'NoCharge'\\n            WHEN taxi_trips.Payment_Type_Id = 4 THEN 'Dispute'\\n         END AS PaymentDescription,\\n       SUM(taxi_trips.Total_Amount) AS Total_Amount\\n  FROM `taxi_dataset.taxi_trips` AS taxi_trips\\n WHERE taxi_trips.Pickup_DateTime BETWEEN '2020-01-01' AND '2020-12-31' \\n   AND Passenger_Count IS NOT NULL\\n   AND Payment_Type_Id IN (1,2,3,4)\\n GROUP BY 1, 2, 3   \\n)\\nSELECT MonthName,\\n       CAST(Credit   AS INTEGER) AS Credit,\\n       CAST(Cash     AS INTEGER) AS Cash,\\n       CAST(NoCharge AS INTEGER) AS NoCharge,\\n       CAST(Dispute  AS INTEGER) AS Dispute\\n  FROM MonthlyData\\n PIVOT(SUM(Total_Amount) FOR PaymentDescription IN ('Credit', 'Cash', 'NoCharge', 'Dispute'))\\nORDER BY MonthNumber;\\n\\n# Show the results\\ndisplay(myDataframe)\\n\\n# Loop through the dataframe\\n# You can now use BigQuery data just like any other datasource\\nfor index, row in myDataframe.iterrows():\\n    print((\\\"MonthName: {MonthName} | Credit: {Credit} | Cash {Cash}\\\").format(MonthName=row['MonthName'].ljust(10),Credit=str(row['Credit']).ljust(10),Cash=str(row['Cash']).ljust(10)))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPlace your SQL Results directly into a Dataframe\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Convert J into a set of feature vectors using F\\nL1 = em.extract_feature_vecs(J, feature_table=F,\\n                            attrs_after='label', show_progress=False)\\n\\n# Predict on L \\npredictions = dt.predict(table=L1, exclude_attrs=['_id', 'ltable_id', 'rtable_id', 'label'])\\n\\n# Show the predictions\\npredictions[0:10]\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nGetting Predictions with the ML Matcher\\nSince we now have a trained decision tree, we can use our matcher to get predictions on the test set. Below, we will show four different ways to get the predictions with the predict command that will be useful in various contexts. \\nGetting a List of Predictions\\nFirst up, we will demonstrate how to get just a list of predictions using the predict command. This is the default method of getting predictions. As shown below, the resulting variable, predictions, is just an array containing the predictions for each of the feature vectors in the test set.\",\"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\\/titanic_svm_advanced.ipynb\\\".\\nThe first task is:\\nAre we nessary perform better than the simpler model?\\nThe real test is to submit the file to kaggle and let their hold out set decide.\\nI did improve my result by ~0.03 with the newly added in name features.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmodel.fit(X,y)\\nholdout_data = pd.read_csv('data\\/test_processed.csv')\\n\\n# rescale age and fare as we did for training data.  This is critical\\n# Note that we can (and should) use the same scaler object we fit above to the training data\\nholdout_data[['Age', 'Fare']] = scaler.transform(holdout_data[['Age', 'Fare']])\\nholdout_data[\\\"PSA\\\"] = holdout_data[\\\"Pclass\\\"]*holdout_data[\\\"Female\\\"]*holdout_data[\\\"Age\\\"]\\nholdout_data[\\\"SP\\\"] = holdout_data[\\\"SibSp\\\"]+holdout_data[\\\"Parch\\\"]\\n\\n#use our new features.\\n#feature_cols=['Pclass','Age','SibSp','Parch','Fare','Female','Title_Dr','Title_Lady','Title_Master','Title_Miss','Title_Mr','Title_Mrs','Title_Rev','Title_Sir']\\nX_holdout=holdout_data[feature_cols]\\nX_holdout.head()\\n\\ny_holdout=model.predict(X_holdout)\\nsamplesubmit = pd.read_csv(\\\"data\\/titanic_submit_example.csv\\\")\\nsamplesubmit[\\\"Survived\\\"]=np.int32(y_holdout)\\nsamplesubmit.to_csv(\\\"data\\/titanic_submit_fancytitle.csv\\\",index=False)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"C = 1000\\nWhen C = 1000, the classifier starts to become very intolerant to misclassified data points and thus the decision boundary becomes less biased and has more variance (i.e. more dependent on the individual data points).\\n\",\"targets\":\"# Create a SVC classifier using an RBF kernel\\nsvm = SVC(kernel='rbf', random_state=0, gamma=.01, C=1000)\\n# Train the classifier\\nsvm.fit(X_xor, y_xor)\\n\\n# Visualize the decision boundaries\\nplot_decision_regions(X_xor, y_xor, classifier=svm)\\nplt.legend(loc='upper left')\\nplt.tight_layout()\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"19.4. Name\\nIs Required: TRUE&nbsp;&nbsp;&nbsp;&nbsp;Type: STRING&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 1.1\\nDescriptive text for lateral tracer advection scheme in ocean (e.g. MUSCL, PPM-H5, PRATHER,...)\\n\",\"targets\":\"# PROPERTY ID - DO NOT EDIT !  \\nDOC.set_id('cmip6.ocean.advection.lateral_tracers.name')  \\n\\n# PROPERTY VALUE: \\n# Set as follows: DOC.set_value(\\\"value\\\")  \\n# TODO - please enter value(s)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"6.\\nHaz una lista de la compra e imprime los siguientes elementos:\\n\\nPenúltimo elemento\\nDel segundo al cuarto elemento\\nLos tres últimos\\nTodos!\\n\\nPor último, elimina el tercer elemento de la lista usando la sentencia del\\n\",\"targets\":\"lista_compra = ['Leche', 'Chocolate', 'Arroz', 'Macarrones']\\n\\nprint(\\\"Penúltimo elemento: \\\", lista_compra[-2])\\nprint(\\\"Del segundo al cuarto elemento: \\\", lista_compra[1:5])\\nprint(\\\"Los tres últimos elementos: \\\", lista_compra[-3:])\\nprint(\\\"Todos: \\\", lista_compra)\\n\\ndel lista_compra[2]\\nprint(lista_compra)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Calcul symbolique.ipynb\\\".\\nThe first task is:\\nOn peut ajouter des contraintes sur les symboles lors de leur création :\\nCan you write Python code for it?\\n\",\"targets\":\"\\nx = Symbol('x', real=True)\\n\\nx.is_imaginary\\n\\nx = Symbol('x', positive=True)\\n\\nx > 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 \\\"Homework6_Soma.ipynb\\\".\\nThe first task is:\\n3) The first daily forecast is the forecast for today. For the place you decided on up above, how much of the moon is currently visible?\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint(forecast['daily'].keys())\\n\\nforecast['daily']['data']\\n\\nprint(type(forecast['daily']['data']))\\nprint(forecast['daily']['data'][0])\\n\\nfirst_daily_forecast = forecast['daily']['data']\\n\\n\\nfor item in first_daily_forecast[:1]: \\n    print(\\\"In the first daily forecast\\\", item['moonPhase'], \\\"of the moon is currently visible\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2.2. Summary\\nSummarizing, the steps to design a Bayesian parametric regresion algorithm are the following:\\n\\nAssume a parametric data model $p(s| {\\\\bf x},{\\\\bf w})$ and a prior distribution $p({\\\\bf w})$.\\nUsing the data model and the i.i.d. assumption, compute $p({\\\\bf s}|{\\\\bf w})$.\\nApplying the bayes rule, compute the posterior distribution $p({\\\\bf w}|{\\\\bf s})$.\\nCompute the MSE estimate of $s$ given ${\\\\bf x}$.\\n\\n3. Bayesian regression for a Gaussian model.\\nWe will apply the above steps to derive a Bayesian regression algorithm for a Gaussian model.\\n3.1. Step 1: The Gaussian model.\\nLet as assume that the likelihood function is given by the Gaussian model described in Sec. 1.3.2.\\n$$\\ns~|~{\\\\bf w} \\\\sim {\\\\cal N}\\\\left({\\\\bf z}^\\\\top{\\\\bf w}, \\\\sigma_\\\\varepsilon^2 {\\\\bf I} \\\\right)\\n$$\\nand that the prior is also Gaussian\\n$$\\n{\\\\bf w} \\\\sim {\\\\cal N}\\\\left({\\\\bf 0},{\\\\pmb \\\\Sigma}_{p} \\\\right)\\n$$\\n3.2. Step 2: Complete data likelihood\\nUsing the i.i.d. assumption, \\n$$\\n{\\\\bf s}~|~{\\\\bf w} \\\\sim {\\\\cal N}\\\\left({\\\\bf Z}{\\\\bf w},\\\\sigma_\\\\varepsilon^2 {\\\\bf I} \\\\right)\\n$$\\n3.3. Step 3: Posterior weight distribution\\nThe posterior distribution of the weights can be computed using the Bayes rule\\n$$p({\\\\bf w}|{\\\\bf s}) = \\\\frac{p({\\\\bf s}|{\\\\bf w})~p({\\\\bf w})}{p({\\\\bf s})}$$\\nSince both $p({\\\\bf s}|{\\\\bf w})$ and $p({\\\\bf w})$ follow a Gaussian distribution, we know also that the joint distribution and the posterior distribution of ${\\\\bf w}$ given ${\\\\bf s}$ are also Gaussian. Therefore,\\n$${\\\\bf w}~|~{\\\\bf s} \\\\sim {\\\\cal N}\\\\left({\\\\bf w}\\\\text{MSE}, {\\\\pmb\\\\Sigma}{\\\\bf w}\\\\right)$$\\nAfter some algebra, it can be shown that mean and the covariance matrix of the distribution are:\\n$${\\\\pmb\\\\Sigma}{\\\\bf w} = \\\\left[\\\\frac{1}{\\\\sigma\\\\varepsilon^2} {\\\\bf Z}^{\\\\top}{\\\\bf Z} + {\\\\pmb \\\\Sigma}_p^{-1}\\\\right]^{-1}$$\\n$${\\\\bf w}\\\\text{MSE} = {\\\\sigma\\\\varepsilon^{-2}} {\\\\pmb\\\\Sigma}_{\\\\bf w} {\\\\bf Z}^\\\\top {\\\\bf s}$$\\nExercise 1:\\nConsider the dataset with one-dimensional inputs given by\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# True data parameters\\nw_true = 3\\nstd_n = 0.4\\n\\n# Generate the whole dataset\\nn_max = 64\\nX_tr = 3 * np.random.random((n_max,1)) - 0.5\\nS_tr =  w_true * X_tr + std_n * np.random.randn(n_max,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 \\\"07_ivp.ipynb\\\".\\nThe first task is:\\nSimilar to forward Euler is the backward Euler method which, as you may have guessed, evaluates the function $f$ at the updated time so that\\n$$\\n    U^{n+1} = U^n + \\\\Delta t f(t_{n+1}, U^{n+1}).\\n$$\\nSchemes where the function $f$ is evaluated at the unknown time are called implicit methods.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nt = numpy.linspace(0.0, 1.6e3, 100)\\nc_0 = 1.0\\ndecay_constant = numpy.log(2.0) \\/ 1600.0\\n\\nfig = plt.figure()\\naxes = fig.add_subplot(1, 1, 1)\\naxes.plot(t, c_0 * numpy.exp(-decay_constant * t), label=\\\"True Solution\\\")\\n\\n# Plot Euler step\\ndt = 1e3\\nu_np = c_0 + dt * (-decay_constant * c_0 * numpy.exp(-decay_constant * dt))\\naxes.plot((0.0, dt), (c_0, u_np), 'k')\\naxes.plot((dt, dt), (u_np, c_0 * numpy.exp(-decay_constant * dt)), 'k--')\\naxes.plot((0.0, 0.0), (c_0, c_0 * numpy.exp(-decay_constant * dt)), 'k--')\\naxes.plot((0.0, dt), (c_0 * numpy.exp(-decay_constant * dt), c_0 * numpy.exp(-decay_constant * dt)), 'k--')\\naxes.text(400, u_np - 0.05, '$\\\\Delta t$', fontsize=16)\\n\\naxes.set_title(\\\"Radioactive Decay with $t_{1\\/2} = 1600$ years\\\")\\naxes.set_xlabel('t (years)')\\naxes.set_ylabel('$c$')\\naxes.set_xlim(-1e2, 1.6e3)\\naxes.set_ylim((0.5,1.0))\\nplt.show()\\n\\nc_0 = 1.0\\ndecay_constant = numpy.log(2.0) \\/ 1600.0\\nf = lambda t, u: -decay_constant * u\\n\\nt_exact = numpy.linspace(0.0, 1.6e3, 100)\\nu_exact = c_0 * numpy.exp(-decay_constant * t_exact)\\n\\n# Implement backwards Euler\\nt_backwards = numpy.linspace(0.0, 1.6e3, 10)\\ndelta_t = t_backwards[1] - t_backwards[0]\\nu_backwards = numpy.empty(t_backwards.shape)\\nu_backwards[0] = c_0\\nfor n in xrange(0, t_backwards.shape[0] - 1):\\n    u_backwards[n + 1] = u_backwards[n] \\/ (1.0 + decay_constant * delta_t)\\n\\nfig = plt.figure()\\naxes = fig.add_subplot(1, 1, 1)\\naxes.plot(t_backwards, u_backwards, 'or', label=\\\"Backwards Euler\\\")\\naxes.plot(t_exact, u_exact, 'k--', label=\\\"True Solution\\\")\\n\\naxes.set_title(\\\"Backwards Euler\\\")\\naxes.set_xlabel(\\\"t (years)\\\")\\naxes.set_xlabel(\\\"$c(t)$\\\")\\naxes.set_ylim((0.4,1.1))\\naxes.legend()\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<div class=\\\"alert alert-warning\\\">\\n<b>What has been the effect of excluding best matches that do not have an RBBH reverse match?<\\/b>\\n<\\/div>\\n\\nNext, we can inspect the query and subject coverage of RBBH results, compared to the one-way forward BLAST matches by executing the cell below.\\n\",\"targets\":\"# Plot 2D histograms of query coverage against subject coverage for the \\n# one-way forward matches, and those retained after calculating RBBH\\nrbbh.plot_hist2d(data_fwd.query_coverage, data_fwd.subject_coverage,\\n                      \\\"one-way query COV\\\", \\\"one-way subject COV\\\", \\n                      \\\"one-way coverage comparison\\\")\\nrbbh.plot_hist2d(data_rbbh.query_coverage_x, data_rbbh.subject_coverage_x,\\n                      \\\"RBBH (fwd) query COV\\\", \\\"RBBH (fwd) subject COV\\\", \\n                      \\\"RBBH_comparisons.ipynbH coverage comparison\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Investigate Data.ipynb\\\".\\nThe first task is:\\nHere is the difference between the player getting the highest salary and the one participating the more winning games.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nplot_correlation2(data=highest_salaries_players_with_score, x_var=\\\"score\\\", y_var=\\\"salary\\\", title='Correlation between Salary and Score')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Comparing NFW, Einasto and Hernquist profiles $\\\\rho(r) \\/\\\\rho_m$\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Colossus density profiles\\ncol_rho_nfw = col_nfw.density (r * cosmo.h () * 1.0e3) * (cosmo.h2 () * 1.0e9)\\n\\n# NumCosmo density profiles\\nnc_rho_nfw  = np.array (nc_nfw.eval_density_array (cosmo, r, 1.0, 1.0, z))\\n\\n# CCL density profiles\\n# CCL input: comoving distance \\nccl_rho_nfw = ccl_nfw.real (cosmo_ccl, r \\/ a, Mvir, a, mdef) \\/ a**3\\n\\n# CT density profile\\n\\nplt.figure()\\nfig, axs = plt.subplots (2, sharex=True, gridspec_kw={'hspace': 0}, figsize=(14,7))\\n\\naxs[0].set_xscale ('log')\\naxs[0].set_yscale ('log')\\naxs[1].set_yscale ('log')\\naxs[1].set_xlabel(r'$r$[Mpc]')\\naxs[0].set_ylabel(r'$\\\\rho (r) \\/ \\\\rho_m$')\\naxs[1].set_ylabel(r'$\\\\rho_{\\\\mathrm{i}} (r) \\/ \\\\rho_{\\\\mathrm{nc}} - 1$')\\naxs[0].plot (r, col_rho_nfw, '-', label = 'NFW - Col')\\naxs[0].plot (r, nc_rho_nfw,  '-', label = 'NFW - NC')\\naxs[0].plot (r, ccl_rho_nfw, '-', label = 'NFW - CCL')\\naxs[0].plot (r, ct_rho_nfw,  '-', label = 'NFW - CT')\\n\\naxs[1].plot (r, np.abs (col_rho_nfw \\/ nc_rho_nfw  - 1.0), '-', label = \\\"NFW - CMP - Col\\\")\\naxs[1].plot (r, np.abs (ccl_rho_nfw \\/ nc_rho_nfw - 1.0),  '-', label = \\\"NFW - CMP - CCL\\\")\\naxs[1].plot (r, np.abs (ct_rho_nfw \\/ nc_rho_nfw - 1.0),   '-', label = \\\"NFW - CMP - CT\\\")\\n\\naxs[0].legend(loc='best')\\naxs[1].legend(loc='best')\\naxs[1].grid()\\n\\nplt.show ()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# create a new list of tokens by applying the metaphone method to all tokens from the words list\\nwords2=list(map(metaphone,words))\\nterm_labels=list(zip(words2,words))\\n\\nprint(\\\"Number of words in metaphone format: %i\\\" % len(words2))\\nfor i,val in enumerate(words2):\\n    print(str(i)+\\\":\\\\t \\\"+str(val))\\n\\n# calculate the triangle dis tance list as above\\nr=np.triu_indices(n=len(words2), k=1)\\nr\\n\\nr2=np.apply_along_axis(d, 0, r)\\nr2\\n\\nmethod_name='single'\\nZ=scipycluster.linkage(r2,method=method_name)\\n\\nplt.figure(figsize=(25, 10))\\nplt.title('Hierarchical Clustering Dendrogram - Method: '+method_name.title())\\nplt.xlabel('Term (in Metaphone\\/Original)')\\nplt.ylabel('Distance')\\nscipycluster.dendrogram(\\n        Z,\\n        leaf_rotation=90.,  # rotates the x axis labels\\n        leaf_font_size=16.,  # font size for the x axis labels\\n        labels=term_labels\\n    )\\nplt.show()\\n\\nwords2=list(map(metaphone,words))\\nterm_labels=list(zip(words2,words))\\n\\nprint(\\\"Number of words in metaphone format: %i\\\" % len(words2))\\nfor i,val in enumerate(words2):\\n    print(str(i)+\\\":\\\\t \\\"+str(val))\\n    \\nr=np.triu_indices(n=len(words2), k=1)\\nr\\n\\nr2=np.apply_along_axis(d, 0, r)\\nr2\\n\\nmethod_name='average'\\nZ=scipycluster.linkage(r2,method=method_name)\\n\\nplt.figure(figsize=(25, 10))\\nplt.title('Hierarchical Clustering Dendrogram - Method: '+method_name.title())\\nplt.xlabel('Term (in Metaphone\\/Original)')\\nplt.ylabel('Distance')\\nscipycluster.dendrogram(\\n        Z,\\n        leaf_rotation=90.,  # rotates the x axis labels\\n        leaf_font_size=16.,  # font size for the x axis labels\\n        labels=term_labels\\n    )\\nplt.show()\\n\\nwords2=list(map(soundex,words))\\nterm_labels=list(zip(words2,words))\\n\\nprint(\\\"Number of words in soundex format: %i\\\" % len(words2))\\nfor i,val in enumerate(words2):\\n    print(str(i)+\\\":\\\\t \\\"+str(val))\\n    \\nr=np.triu_indices(n=len(words2), k=1)\\nr\\n\\nr2=np.apply_along_axis(d, 0, r)\\nr2\\n\\nmethod_name='single'\\nZ=scipycluster.linkage(r2,method=method_name)\\n\\nplt.figure(figsize=(25, 10))\\nplt.title('Hierarchical Clustering Dendrogram - Method:...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSamples with Phonetic Preprocessing\\nThe following examples follow the logic presented above. However, the make use of the metaphone and soundex methods provided by Jellyfish to convert the tokens to their phonetic equivalents before creating the distance matrix and visualizing the results.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"After specifying an experiment above, run the next block to get files for that experiment.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmtools = reload(mtools)\\nfiles = mtools.get_files_for_experiment(experiment.value)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Again, the prediction is shown as the color of the cross. You can see that the prediction for the new data point at the top left is not the same as the prediction when we used only one neighbor.\\nWhile this illustration is for a binary classification problem, this method can be applied to datasets with any number of classes. For more classes, we count how many neighbors belong to each class and again predict the most common class.\\nAnalyzing Decision Boundary as k varies\\nFor two-dimensional datasets, we can also illustrate the prediction for all possible test points in the xy-plane. We color the plane according to the class that would be assigned to a point in this region. This lets us view the decision boundary, which is the divide between where the algorithm assigns class 0 versus where it assigns class 1. The following code produces the visualizations of the decision boundaries for one, three, and nine neighbors.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom matplotlib.colors import ListedColormap\\ncm2 = ListedColormap(['#0000aa', '#ff2020'])\\n\\ndef plot_2d_separator(classifier, X, fill=False, ax=None, eps=None, alpha=1,\\n                      cm=cm2, linewidth=None, threshold=None, linestyle=\\\"solid\\\"):\\n    # binary?\\n    if eps is None:\\n        eps = X.std() \\/ 2.\\n\\n    if ax is None:\\n        ax = plt.gca()\\n\\n    x_min, x_max = X[:, 0].min() - eps, X[:, 0].max() + eps\\n    y_min, y_max = X[:, 1].min() - eps, X[:, 1].max() + eps\\n    xx = np.linspace(x_min, x_max, 100)\\n    yy = np.linspace(y_min, y_max, 100)\\n\\n    X1, X2 = np.meshgrid(xx, yy)\\n    X_grid = np.c_[X1.ravel(), X2.ravel()]\\n    try:\\n        decision_values = classifier.decision_function(X_grid)\\n        levels = [0] if threshold is None else [threshold]\\n        fill_levels = [decision_values.min()] + levels + [decision_values.max()]\\n    except AttributeError:\\n        # no decision_function\\n        decision_values = classifier.predict_proba(X_grid)[:, 1]\\n        levels = [.5] if threshold is None else [threshold]\\n        fill_levels = [0] + levels + [1]\\n    if fill:\\n        ax.contourf(X1, X2, decision_values.reshape(X1.shape),\\n                    levels=fill_levels, alpha=alpha, cmap=cm)\\n    else:\\n        ax.contour(X1, X2, decision_values.reshape(X1.shape), levels=levels,\\n                   colors=\\\"black\\\", alpha=alpha, linewidths=linewidth,\\n                   linestyles=linestyle, zorder=5)\\n\\n    ax.set_xlim(x_min, x_max)\\n    ax.set_ylim(y_min, y_max)\\n    ax.set_xticks(())\\n    ax.set_yticks(())\\n\\n\\nfig, axes = plt.subplots(1, 3, figsize=(10, 3))\\n\\nfor n_neighbors, ax in zip([1, 3, 9], axes):\\n    # the fit method returns the object self, so we can instantiate\\n    # and fit in one line\\n    clf = KNeighborsClassifier(n_neighbors=n_neighbors).fit(X, y)\\n    plot_2d_separator(clf, X, fill=True, eps=0.5, ax=ax, alpha=.4)\\n    discrete_scatter(X[:, 0], X[:, 1], y, ax=ax)\\n    ax.set_title(\\\"{} neighbor(s)\\\".format(n_neighbors))\\n    ax.set_xlabel(\\\"feature 0\\\")\\n    ax.set_ylabel(\\\"feature 1\\\")\\naxes[0].legend(loc=3)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Creating and Running ODESimulator\\nYou can create a Simulator with Model and World like\\n\",\"targets\":\"with reaction_rules():\\n    A + B > C | 0.01  # equivalent to create_binding_reaction_rule\\n    C > A + B | 0.3   # equivalent to create_unbinding_reaction_rule\\n\\nm = get_model()\\n\\nsim = ode.ODESimulator(m, w)\\nsim.run(10.0)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"L5 - Decision Tree.ipynb\\\".\\nThe first task is:\\nAnd we use Sun_level as labels\\nCan you write Python code for it?\\n\",\"targets\":\"\\ny_train = train.Sun_level\\ny_test = test.Sun_level\",\"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:\\nor the stripped strings(unnecessary spaces are removed)\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfor string in soup.stripped_strings:\\n    print(repr(string))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Huntsman Telephoto Array specifications.ipynb\\\".\\nThe first task is:\\nEach imaging unit shall deliver an instantaneous field of view of $2.6 \\\\pm 0.1 \\\\times 1.9 \\\\pm 0.1$ degrees \\n\\nExposure time\\nIndividual exposure times of 5-30 minutes are anticipated (5-10 minutes for broadband observations, 30 minutes for narrowband).\\nCan you write Python code for it?\\n\",\"targets\":\"\\nexposure_times = ((5, 10, 30) * u.minute)\\nexposure_times\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Intro-Numerical-Computing-Python.ipynb\\\".\\nThe first task is:\\nIn the first example we retrieved all the elements of x that are larger than 5 (read \\\"x where x is greater than 5\\\"). In the second example we retrieved those elements of x that did not equal six.   The third example is slightly more complicated. We combined the logical_or function with comparison and indexing.  This allowed us to return those elements of the array x that are either less than four or greater than six. Combining indexing and comparison is a powerful concept. See the numpy documentation on logical functions for more information.\\nGenerating Regular Sequences\\nCreating sequences of numbers that are separated by a specified value or that follow a particular patterns turns out to be a common task in programming. Python and NumPy have functions to simplify this task.\\nCan you write Python code for it?\\n\",\"targets\":\"\\narange(10)\\n\\n# generate numbers from 3 to 12 (non-inclusive) stepping by 4\\narange(3, 12, 4)  \\n\\narange(1,10,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 \\\"Cal3-PythonGraphes.ipynb\\\".\\nThe first task is:\\nOr, alternatively, we can request that matplotlib uses LaTeX to render the text elements in the figure:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmatplotlib.rcParams.update({'font.size': 18, 'text.usetex': True})\\n\\nfig, ax = plt.subplots()\\n\\nax.plot(x, x**2, label=r\\\"$y = \\\\alpha^2$\\\")\\nax.plot(x, x**3, label=r\\\"$y = \\\\alpha^3$\\\")\\nax.legend(loc=2) # upper left corner\\nax.set_xlabel(r'$\\\\alpha$')\\nax.set_ylabel(r'$y$')\\nax.set_title('title');\\nshow()\\n\\n# restore\\nmatplotlib.rcParams.update({'font.size': 12, 'font.family': 'sans', 'text.usetex': False})\",\"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.1\\/tutorials\\/MESH.ipynb\\\".\\nThe first task is:\\ninclude_times\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint b['include_times']\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"\\\"\\\"A demonstration of writing well documented Python code.\\n\\nThis snippet demonstrates how a well documented code should look.\\nEach method and class is documented, and there is also\\ndocumentation for the script itself.\\n\\\"\\\"\\\"\\nimport os\\n\\n\\nclass Path:\\n    \\\"\\\"\\\"Represent a filesystem path.\\n    \\n    It is used to simplify the work with paths across different\\n    operating systems. The initialization method takes a string and\\n    populates the full path property along with \\\"parts,\\\" which is a\\n    version of the path after we split it using path separator\\n    characters.\\n\\n    Basic Usage:\\n\\n    >>> Path(r'C:\\\\Yossi').get_drive_letter()\\n    'C:'\\n    >>> str(Path(r'C:\\\\Messed\\/Up\\/Path\\\\To\\\\file.png'))\\n    'C:\\/Messed\\/Up\\/Path\\/To\\/file.png'\\n    \\\"\\\"\\\"\\n\\n    def __init__(self, path):\\n        self.fullpath = path\\n        self.parts = list(self.get_parts())\\n\\n    def get_parts(self):\\n        \\\"\\\"\\\"Split the path, return each part separately.\\n\\n        Each \\\"part\\\" of the path can be defined as a drive, folder, or\\n        file, separated by a forward slash (\\/, typically used in\\n        Linux\\/Mac) or by a backslash (usually used in Windows).\\n\\n        path -- String that consists of a drive (if applicable),\\n                folders, and files, separated by a forward slash or by\\n                a backslash.\\n        \\\"\\\"\\\"\\n        current_part = \\\"\\\"\\n        for char in self.fullpath:\\n            if char in r\\\"\\\\\\/\\\":\\n                yield current_part\\n                current_part = \\\"\\\"\\n            else:\\n                current_part = current_part + char\\n        if current_part != \\\"\\\":\\n            yield current_part\\n\\n    def get_drive_letter(self):\\n        \\\"\\\"\\\"Return the drive letter of the path, when applicable.\\\"\\\"\\\"\\n        return self.parts[0].rstrip(\\\":\\\")\\n\\n    def get_dirname(self):\\n        \\\"\\\"\\\"Return the full path without the last part.\\\"\\\"\\\"\\n        path = \\\"\\/\\\".join(self.parts[:-1])\\n        return Path(path)\\n\\n    def get_basename(self):\\n        \\\"\\\"\\\"Return the last part of the path.\\\"\\\"\\\"\\n        return self.parts[-1]\\n\\n    def get_extension(self):\\n        \\\"\\\"\\\"Return the...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<p style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\n    סוג כזה של תיעוד נקרא \\\"<dfn>מחרוזת תיעוד מרובת שורות<\\/dfn>\\\" (<dfn>Multi-line Docstring<\\/dfn>).<br>\\n    נכתוב אותו כדי לעזור למי שישתמש בפונקציה להבין מה מטרתה, אילו פרמטרים היא מצפה לקבל ואילו ערכים יוחזרו ממנה.\\n<\\/p>\\n\\n<p style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\n    היכן נשתמש בתיעוד מרובה שורות?\\n<\\/p>\\n\\n<ul style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\n    <li>בראש הקוד – נסכם מה מטרת הקוד, ונסביר בקצרה מה הוא כולל.<\\/li>\\n    <li>בראש מחלקה – נסכם את התנהגות המחלקה ונתעד את הפעולה <code>__init__<\\/code>.<\\/li>\\n    <li>בפונקציה או בפעולה – נסכם:\\n        <ul>\\n            <li>מה מטרתה.<\\/li>\\n            <li>אילו ארגומנטים היא מצפה לקבל.<\\/li>\\n            <li>מהם ערכי ההחזרה שלה.<\\/li>\\n            <li>אילו שגיאות היא עלולה להחזיר.<\\/li>\\n            <li>על מה היא משפיעה חוץ מאשר על המשתנים בפונקציה עצמה (נניח – כתיבה לקובץ).<\\/li>\\n        <\\/ul>\\n    <\\/li>\\n<\\/ul>\\n\\n<span style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">דוגמה לתיעוד בסיסי<\\/span>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"DEEP LEARNING\\/NLP\\/LSTM RNN\\/Toxic multiclass prediction Glove + Bidirection LSTM.ipynb\\\".\\nThe first task is:\\nStandard keras preprocessing, to turn each comment into a list of word indexes of equal length (with truncation or padding as needed).\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntokenizer = Tokenizer(num_words=max_features)\\ntokenizer.fit_on_texts(list(list_sentences_train))\\nlist_tokenized_train = tokenizer.texts_to_sequences(list_sentences_train)\\nlist_tokenized_test = tokenizer.texts_to_sequences(list_sentences_test)\\nX_t = pad_sequences(list_tokenized_train, maxlen=maxlen)\\nX_te = pad_sequences(list_tokenized_test, maxlen=maxlen)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# f, ax = plt.subplots(2, 2)\\n\\n# for i in range(2):\\n#     for j in range(2):\\n#         plt.sca(ax[i,j])\\n#         plt.plot(np.random.rand(20))\\n#         plt.xlabel('x')\\n#         plt.ylabel('y')\\n\\n# plt.tight_layout()\\n\\nprint (year[0,99])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIn many cases, it is easier to use the subplots function, which creates a new Figure along with an array of Axes objects that can be indexed in a rational manner:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"HW01-Intro_to_Pandas\\/Intro to Pandas.ipynb\\\".\\nThe first task is:\\nWe can use the drop method to remove rows or columns, which by default drops rows. We can be explicit by using the axis argument:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndata_nomonth = data.drop('month', axis=1)\\ndata_nomonth\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Dashboard Heading\\nThis widget summarizes the topic used to track your meetups and the parameters used to filter the RSVP stream.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n%%html\\n<template is=\\\"urth-core-bind\\\" channel=\\\"meetups\\\">\\n    <style>\\n        .topics-desc {\\n            font-size: larger;\\n        }\\n        .topics-desc span {\\n            font-style: italic;\\n        }\\n    <\\/style>\\n    <div class=\\\"topics-desc\\\">\\n       Showing upcoming meetups for the <span>[[upcoming_label]]<\\/span> topic. Meetup candidates are generated using the following topic filters: <span>[[cand_topics_label]]<\\/span>\\n    <\\/div>\\n<\\/template>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%store -r averagediff_real\\n\\nplt.xlabel('Day') \\nplt.ylabel('Average number of tweets')\\nplt.step(range(1,len(averagediff)+1),averagediff, 'r', label=\\\"fake news\\\")\\nplt.step(range(1,len(averagediff_real)+1),averagediff_real, 'g', label=\\\"real news\\\")\\nplt.legend()\\nplt.title('Average diffusion for both types of news')\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPlot average diffusion for both real and fake news on one graph\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"!pip install pulp\\n\\nfrom pulp import LpMaximize, LpProblem, lpSum, LpVariable\\n\\nprob = LpProblem(\\\"Melhor_Escalacao\\\", LpMaximize)\\ny = LpVariable.dicts(\\\"Atl\\\",df_rodada.index,0,1,cat='Binary')\\nprob += lpSum([z[i] * y[i] for i in y])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPrimeiro, iniciamos o problema de otimização e definimos uma função objetivo.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create site profile\\nThis is about the simplest profile that we can create. Linear-elastic soil and rock.\\n\",\"targets\":\"profile = pysra.site.Profile(\\n    [\\n        pysra.site.Layer(\\n            pysra.site.DarendeliSoilType(18.0, plas_index=0, ocr=1, stress_mean=100),\\n            10,\\n            400,\\n        ),\\n        pysra.site.Layer(\\n            pysra.site.DarendeliSoilType(18.0, plas_index=0, ocr=1, stress_mean=200),\\n            10,\\n            450,\\n        ),\\n        pysra.site.Layer(\\n            pysra.site.DarendeliSoilType(18.0, plas_index=0, ocr=1, stress_mean=400),\\n            30,\\n            600,\\n        ),\\n        pysra.site.Layer(pysra.site.SoilType(\\\"Rock\\\", 24.0, None, 0.01), 0, 1200),\\n    ]\\n)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Creating a new Benchmark object\\nTo instantiate the Benchmark class, a recommender object of type RecoBasedOn is required (think: \\\"What do I want to benchmark?\\\"), like so:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nbenchmark = Benchmark(recommender)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Weight vector:\\nw = [4, 8]   # Try different weights\\n\\n# Create a rectangular grid.\\nx_min = -1\\nx_max = 1\\nh = (x_max - x_min) \\/ 200\\nxgrid = np.arange(x_min, x_max, h)\\nxx0, xx1 = np.meshgrid(xgrid, xgrid)\\n\\n# Compute the logistic map for the given weights, and plot\\nZ = logistic(w[0]*xx0 + w[1]*xx1)\\n\\nfig = plt.figure()\\nax = fig.gca(projection='3d')\\nax.plot_surface(xx0, xx1, Z, cmap=plt.cm.copper)\\nax.contour(xx0, xx1, Z, levels=[0.5], colors='b', linewidths=(3,))\\nplt.xlabel('$x_0$')\\nplt.ylabel('$x_1$')\\nax.set_zlabel('P(1|x,w)')\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIt is straightforward to see that the logistic function has the following properties:\\n\\nP1: Probabilistic output: $\\\\quad 0 \\\\le g(t) \\\\le 1$\\nP2: Symmetry: $\\\\quad g(-t) = 1-g(t)$\\nP3: Monotonicity: $\\\\quad g'(t) = g(t)\\\\cdot [1-g(t)] \\\\ge 0$\\n\\nExercise 1: Verify properties P2 and P3.\\nExercise 2: Implement a function to compute the logistic function, and use it to plot such function in the inverval $[-6,6]$.\\n2.2. Classifiers based on the logistic model.\\nThe MAP classifier under a logistic model will have the form\\n$$P_{Y|{\\\\bf X}}(1|{\\\\bf x}, {\\\\bf w}) = g({\\\\bf w}^\\\\intercal{\\\\bf x}) \\\\quad\\\\mathop{\\\\gtrless}^{\\\\hat{y}=1}_{\\\\hat{y}=0} \\\\quad \\\\frac{1}{2} $$\\nTherefore\\n$$\\n2 \\\\quad\\\\mathop{\\\\gtrless}^{\\\\hat{y}=1}_{\\\\hat{y}=0} \\\\quad\\n1 + \\\\exp(-{\\\\bf w}^\\\\intercal{\\\\bf x}) $$\\nwhich is equivalent to\\n$${\\\\bf w}^\\\\intercal{\\\\bf x} \\n\\\\quad\\\\mathop{\\\\gtrless}^{\\\\hat{y}=1}_{\\\\hat{y}=0}\\\\quad \\n0 $$\\nThus, the classifiers based on the logistic model are given by linear decision boundaries passing through the origin, ${\\\\bf x} = {\\\\bf 0}$.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Absolutely any Python installation will come with these. However, you still have to import them to access them in your program.\\nIf you are so inclined, you can see the full Python default module index here: https:\\/\\/docs.python.org\\/3\\/py-modindex.html.\\nIt's quite a bit! These are all available to you when using Python (don't even bother trying to memorize these; in looking over this list just now, I'm amazed at how many I didn't even know existed).\\nOnce you've imported the module, you can access all its functions via the \\\"dot-notation\\\":\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport random\\nrandom.randint(0, 1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Branching\\nWe need to store the paths and whether we have been there before, and if yes, then which route were we taking. A simple queue should suffice.\\nThe approach we are going to use is that of breadth-first-search. In this approach, we identify all possible directions we can currently move in and put them in the queue. Then while the stack is not empty, we pop a move out, and repeat the directions it can take and so on until we reach the end-point, at which, we store the length of the path we took.\\nTo store the length of the path, each move put on the stack must have an accompanying count of the steps it took to reach there. It is possible to apply heuristic by storing an index of paths sorted by the length and giving priority to pursuing paths with a shorter length first, or those that are nearer to the end-point.\\nOne very important thing to note: we must not travel to the same point again - otherwise we'll keep chasing our own tails in recursive cycles (or an infinite while loop, take your pick). To prevent that, we have to maintain an index of points we have already traversed. We use a dictionary to hold this index, which stores the number of steps we took to traverse to this point. If there comes a move that reaches the same point in lesser number of steps, we know that it is a shorter route, and we continue traversing it. If the move has more number of steps to reach the same point, then it is not an optimum path, and do not need to continue along it.\\n\",\"targets\":\"queue = []\\npoints_traversed = {}\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<h2>1. Un exemple jouet\\n\",\"targets\":\"alpha = 4\\nsize = 100\\na = np.random.uniform(-1, alpha - 1, (size, 2))\\nb = np.random.uniform(-2, alpha - 2, (size, 2))\\nc = np.random.uniform(-3, alpha - 3, (size, 2))\\nd = np.random.uniform(0, alpha, (size, 2))\\ne = np.random.uniform(1, 1 + alpha, (size, 2))\\nf = np.random.uniform(2, 2 + alpha, (size, 2))\\nX = np.concatenate((a,b,c,d,e,f),axis=0)\\npca = PCA(n_components=2)\\nplt.scatter(X[:,0],X[:,1])\\npca.fit(X)\\nprint(pca.explained_variance_ratio_)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%time\\nX = vectorizer.transform( graphs )\\nprint 'Instances: %d ; Features: %d with an avg of %d features per instance' % (X.shape[0], X.shape[1],  X.getnnz()\\/X.shape[0])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\ncompute the vector encoding of each instance in a sparse data matrix\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\".ipynb_checkpoints\\/Getting_Started-checkpoint.ipynb\\\".\\nThe first task is:\\nNot much information here. Let's print out information on the builds associated with the build executions:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint([(i, i.build) for i in rs.build_execs])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# ignore this, it is just technical code\\n# should come from a lib, consider it to appear magically \\n# http:\\/\\/scikit-learn.org\\/stable\\/auto_examples\\/neighbors\\/plot_classification.html\\n\\nimport matplotlib.pyplot as plt\\nfrom matplotlib.colors import ListedColormap\\n\\ncmap_print = ListedColormap(['#AA8888', '#004000', '#FFFFDD'])\\ncmap_bold = ListedColormap(['#AA4444', '#006000', '#AAAA00'])\\ncmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#FFFFDD'])\\nfont_size=25\\n\\ndef meshGrid(x_data, y_data):\\n    h = 1  # step size in the mesh\\n    x_min, x_max = x_data.min() - 1, x_data.max() + 1\\n    y_min, y_max = y_data.min() - 1, y_data.max() + 1\\n    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\\n                         np.arange(y_min, y_max, h))\\n    return (xx,yy)\\n    \\ndef plotPrediction(clf, x_data, y_data, x_label, y_label, colors, title=\\\"\\\", mesh=True, fname=None):\\n    xx,yy = meshGrid(x_data, y_data)\\n    plt.figure(figsize=(20,10))\\n\\n    if clf and mesh:\\n        Z = clf.predict(np.c_[yy.ravel(), xx.ravel()])\\n        # Put the result into a color plot\\n        Z = Z.reshape(xx.shape)\\n        plt.pcolormesh(xx, yy, Z, cmap=cmap_light)\\n    \\n    plt.xlim(xx.min(), xx.max())\\n    plt.ylim(yy.min(), yy.max())\\n    if fname:\\n        plt.scatter(x_data, y_data, c=colors, cmap=cmap_print, s=200, marker='o', edgecolors='k')\\n    else:\\n        plt.scatter(x_data, y_data, c=colors, cmap=cmap_bold, s=80, marker='o', edgecolors='k')\\n    plt.xlabel(x_label, fontsize=font_size)\\n    plt.ylabel(y_label, fontsize=font_size)\\n    plt.title(title, fontsize=font_size)\\n    if fname:\\n        plt.savefig(fname)\\n\\nfrom sklearn.model_selection import train_test_split\\n\\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42, stratify=y)\\n\\nX_train.shape, y_train.shape, X_test.shape, y_test.shape\\n\\nX_train_kmh_age = X_train[:, :2]\\nX_test_kmh_age = X_test[:, :2]\\nX_train_2_dim = X_train_kmh_age\\nX_test_2_dim = X_test_kmh_age\\n\\n# 0: red\\n# 1: green\\n# 2: yellow\\n\\nclass ClassifierBase:\\n    def predict(self, X):\\n        return...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSecond Step: Visualizing Prediction\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Calgary View\\nNotice that upLevelSymbolId for this view is equal to the symbolId of the Alberta view shown in the previous example. we can see that this is a child of the Canada Custom View.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nget_custom_views(url=auth.url, auth=auth.creds, name=\\\"Calgary\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create structure matrices and across-feature distance matrix\\n\",\"targets\":\"#%% Structure matrices and across-features distance matrix\\nC1 = ot.dist(xs)\\nC2 = ot.dist(xt)\\nM = ot.dist(ys, yt)\\nw1 = ot.unif(C1.shape[0])\\nw2 = ot.unif(C2.shape[0])\\nGot = ot.emd([], [], M)\",\"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_support_vector_machines.ipynb\\\".\\nThe first task is:\\nThat's much better (we cut the error rate in two), but still not great at all for MNIST. If we want to use an SVM, we will have to use a kernel. Let's try an SVC with an RBF kernel (the default).\\nWarning: if you are using Scikit-Learn ≤ 0.19, the SVC class will use the One-vs-One (OvO) strategy by default, so you must explicitly set decision_function_shape=\\\"ovr\\\" if you want to use the OvR strategy instead (OvR is the default since 0.19).\\nCan you write Python code for it?\\n\",\"targets\":\"\\nsvm_clf = SVC(decision_function_shape=\\\"ovr\\\")\\nsvm_clf.fit(X_train_scaled[:10000], y_train[:10000])\\n\\ny_pred = svm_clf.predict(X_train_scaled)\\naccuracy_score(y_train, y_pred)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"DL0110EN\\/4.3.2mist1layer.ipynb\\\".\\nThe first task is:\\n<a id=\\\"ref5\\\"><\\/a>\\n<h2 align=center>Analyze Results<\\/h2>\\n\\nCompare the training loss for each activation:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nplt.plot(training_results_tanch['training_loss'],label='tanh')\\nplt.plot(training_results['training_loss'],label='sim')\\nplt.plot(training_results_relu['training_loss'],label='relu')\\nplt.ylabel('loss')\\nplt.title('training loss iterations')\\nplt.legend()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"By the end of the workshop you will understand what most of these mean.\\nBut rather than listen through a lesson, you get to try and figure what they mean yourself.\\nTo help you with that, here's a function that prints the information from two arrays side by side:\\n\",\"targets\":\"def info_for_two(one_array, another_array):\\n    \\\"\\\"\\\"Prints side-by-side results of running np.info on its inputs.\\\"\\\"\\\"\\n    def info_as_ordered_dict(array):\\n        \\\"\\\"\\\"Converts return of np.infor into an ordered dict.\\\"\\\"\\\"\\n        import collections\\n        import io\\n        buffer = io.StringIO()\\n        np.info(array, output=buffer)\\n        data = (\\n            item.split(':') for item in buffer.getvalue().strip().split('\\\\n'))\\n        return collections.OrderedDict(\\n            ((key, value.strip()) for key, value in data))\\n    one_dict = info_as_ordered_dict(one_array)\\n    another_dict = info_as_ordered_dict(another_array)\\n    name_w = max(len(name) for name in one_dict.keys())\\n    one_w = max(len(name) for name in one_dict.values())\\n    another_w = max(len(name) for name in another_dict.values())\\n    output =  (\\n        f'{name:<{name_w}} : {one:>{one_w}} : {another:>{another_w}}'\\n        for name, one, another in zip(\\n            one_dict.keys(), one_dict.values(), another_dict.values()))\\n    print('\\\\n'.join(output))\\n\\na = np.arange(5)\\nb = a[:]\\ninfo_for_two(a, b)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Color Operations\\nThe following spectra.Color methods return new colors:\\n\\n.blend(other_color, ratio=0.5)\\n.brighten(amount=10)\\n.darken(amount=10)\\n.saturate(amount=10)\\n.desaturate(amount=10)\\n\\nThe parameter for .brighten\\/.darken is a positive\\/negative linear adjustment to the L(ightness) value of the color's Lab representation. (Spectra converts the color to Lab, makes the change, and then converts back to the original color space.)\\nLikewise, the parameter for .saturate\\/.desaturate is a positive\\/negative linear adjustment to the c(hroma) value of the color's Lch representation.\\n\",\"targets\":\"yellow = spectra.html(\\\"yellow\\\").to(\\\"lab\\\")\\n\\ntomato.blend(yellow, 0.25).hexcode\\n\\nswatches([\\n    tomato,\\n    tomato.blend(yellow, 0.25),\\n    tomato.blend(yellow, 0.75),\\n    yellow\\n])\\n\\nswatches([\\n    tomato.brighten(30),\\n    tomato,\\n    tomato.darken(30)\\n])\\n\\nswatches([\\n    tomato.saturate(40),\\n    tomato,\\n    tomato.desaturate(40)\\n])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Commit logs\\nThe messages that are added to the commit command are supposed to give a short (often one-line) description of the changes\\/additions\\/deletions in the commit. If the -m \\\"message\\\" is omitted when invoking the git commit message an editor will be opened for you to type a commit message (for example useful when a longer commit message is required). \\nWe can look at the revision log by using the command git log:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n!git log\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Dia3\\/3_Limite_Shockley_Queisser.ipynb\\\".\\nThe first task is:\\nTiempo de Graficar\\nActividad: Grafica el spectro solar\\nOjo: No se te olvide agregar titulos e informacion a la grafica\\nCompara con el espector visible\\n\\n3-6 Donde perdemos eficiencia?\\nPodemos indentificar 5 partes:\\n\\nConversion de energia a electricidad util\\nEnergia fotonica debajo del bandgap, esta energia no se absorbe y entonces no se gasta.\\nEnergia fotonica en exceso del bandgap: esto es por que el electron y el hoyo se relajan inmediatamente a borde de las bandas. Por ejemplo, para un semiconductor de 1eV-bandgap, un foton de  3eV crea el mismo par electron-hoyo que uno foton de 1.01eV. Esos 2eV de energia extra que tenia el 3eV se pierden.\\nRecombination de electron-hoyos: toda la recombinacion en el punto de maxima energia (max-power-point) se disipa como calor;\\nVoltaje de la celda : el voltaje  max-power-point is less than the bandgap.\\n\\nPodemos poner esto en una ecuacion:\\n$(\\\\text{Energia solar entrante}) = V_{MPP} \\\\times I_{MPP}$<br>\\n$ \\\\qquad + (\\\\text{Energia fotonica debajo del bandgap})$<br>\\n$ \\\\qquad + (\\\\text{Energia fotonica arriba del bandgap} - \\\\text{Numero de fotones arriba del bandgap} \\\\times \\\\text{Energia Bandgap})$<br>\\n$ \\\\qquad + ((\\\\text{Numero de fotones arriba del bandgap}) - I_{MPP} \\/ e) \\\\times (\\\\text{Energia Bandgap})$<br>\\n$ \\\\qquad + I_{MPP} \\\\times (\\\\text{Voltaje del Bandgap} - V_{MPP})$<br>\\n2 - Luz incidente\\nCalcularemos una cantidad mas intuitiva\\nFotones por unidad de tiempo, area y rango de energia\\nHaremos este cambio para hacer calculos en funcion de fotones en vez de numero onda.\\nPara esto definimos FotonesPorTEA (Tiempo, Energia, Area). Convertimos los datos AM1.5 a estas nuevas unidades usando la formula:\\n$\\\\text{FotonesPerTEA} = \\\\frac{d(\\\\text{numero de fotos, por unidad de tiempo, por unidad de area})}{dE} = \\\\frac{d(\\\\text{Energia foton por unidad de area})}{d\\\\lambda} \\\\; \\\\frac{(\\\\text{numero de fotos, por unidad de tiempo, por unidad de area})}{(\\\\text{Energia foton por unidad de area})} \\\\left| \\\\frac{d\\\\lambda}{dE} \\\\right| = $\\n$ = (\\\\text{AM1.5 spectro}) \\\\; \\\\frac{1}{\\\\text{energia foton}}...\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef FotonesPorTEA(Ephoton):\\n    wavelength = nu.hPlanck * nu.c0 \\/ Ephoton\\n    return AM15interp(wavelength) * (1 \\/ Ephoton) * (nu.hPlanck * nu.c0 \\/ Ephoton**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 \\\"HipHopDataExploration\\/HipHopDataExploration.ipynb\\\".\\nThe first task is:\\nBuilding a concordance, gets us to the area of elementary information retrieval (IR)<a href=\\\"#fn1\\\" id=\\\"ref1\\\">1<\\/a>, think, <i> basic search engine<\\/i>. So why do we even need to “normalize” terms? We want to match <b>U.S.A.<\\/b> and <b>USA<\\/b>. Also when we enter <b>roll<\\/b>, we would like to match <b>Roll<\\/b>, and <b>rolling<\\/b>. One way to do this is to stem the word. That is, reduce it down to its base\\/stem\\/root form. As such <b>automate(s)<\\/b>, <b>automatic<\\/b>, <b>automation<\\/b> all reduced to <b>automat<\\/b>. Most stemmers are pretty basic and just chop off standard affixes indicating things like tense (e.g., \\\"-ed\\\") and possessive forms (e.g., \\\"-'s\\\"). Here, we'll use the most popular english language stemmer, the Potter stemmer, which comes with NLTK. \\nOnce our tokens are stemmed, we can rest easy knowing that roll, Rolling, Rolls will all stem to roll.\\n<sup id=\\\"fn1\\\">1. Some of this content has been adapted from Dan Jurafsky's <a href=\\\"https:\\/\\/web.stanford.edu\\/class\\/cs124\\/\\\">Stanford CS124 class<\\/a><a href=\\\"#ref1\\\" title=\\\"Jump back to footnote 1 in the text.\\\"><\\/a><\\/sup>\\nCan you write Python code for it?\\n\",\"targets\":\"\\nporter = nltk.PorterStemmer()\\n\\nstemmer = nltk.PorterStemmer()\\nstemmed_tokens = [stemmer.stem(t) for t in AmericanGangster_corpus]\\n\\nfor token in sorted(set(stemmed_tokens))[860:870]:\\n    print token + ' [' + str(stemmed_tokens.count(token)) + ']'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Instantiate a \\\"coarse\\\" 2-group EnergyGroups object\\ncoarse_groups = mgxs.EnergyGroups()\\ncoarse_groups.group_edges = np.array([0., 0.625, 20.0e6])\\n\\n# Instantiate a \\\"fine\\\" 8-group EnergyGroups object\\nfine_groups = mgxs.EnergyGroups()\\nfine_groups.group_edges = np.array([0., 0.058, 0.14, 0.28,\\n                                    0.625, 4.0, 5.53e3, 821.0e3, 20.0e6])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow we are finally ready to make use of the openmc.mgxs module to generate multi-group cross sections! First, let's define \\\"coarse\\\" 2-group and \\\"fine\\\" 8-group structures using the built-in EnergyGroups class.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<u>Problem 3<\\/u>\\nUse the reduce function to find the produc of all the entries in the list\\n[47,11,42,102,13]\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint reduce(lambda x,y: x*y, [47,11,42,102,13])\\n\\n# note that you can improve the speed of the calculation using built-in functions\\n# or better still: using the numpy module\\nfrom operator import mul\\nimport numpy as np\\na = range(1, 101)\\n\\nprint \\\"\\\\nreduce(lambda x, y: x * y, a)\\\"\\n%timeit reduce(lambda x, y: x * y, a)   # (1)\\n\\nprint \\\"\\\\nreduce(mul, a)\\\"\\n%timeit reduce(mul, a)                  # (2)\\n\\nprint \\\"\\\\nnp.prod(a)\\\"\\na = np.array(a)\\n%timeit np.prod(a)                      # (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 \\\"Assignment1\\/Assignment1.ipynb\\\".\\nThe first task is:\\nSet configurables:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n_DATA_FILEPATH = 'datagovdatasetsviewmetrics.csv'\\n_ROTATION_DEGREES = 90\\n_BOTTOM_MARGIN = 0.35\\n_COLOR_THEME = 'coolwarm'\\n_LABEL_X = 'Organizations'\\n_LABEL_Y = 'Views'\\n_TITLE = 'Organizations with Most Views'\\n_ORGANIZATION_COUNT = 10\\n_MAX_LABEL_LENGTH = 20\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<p style=\\\"text-align:right;direction:rtl;\\\">שעון עולמי<\\/p>\\n<p style=\\\"text-align:right;direction:rtl;\\\">בשאלה זו נכתוב גרסה של שעון עולמי התומך ב־4 אזורי זמן:<br>\\n\\n<ul style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\n    <li>תל אביב – TLV<\\/li>\\n    <li>לונדון – LDN<\\/li>\\n    <li>ניו יורק – NYC<\\/li>\\n    <li>טוקיו – TYO<\\/li>\\n<\\/ul>\\n\\n<p style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\nאם נקבל תל אביב, נחזיר את השעה בתוספת 3 שעות.<br>\\nאם נקבל ניו יורק נחזיר את השעה פחות 4.<br>\\nאם נקבל טוקיו נחזיר את השעה ועוד 9.<br>\\nבכל מקרה אחר נחזיר את השעה כמו שקיבלנו אותה.\\n<\\/p>\\n\\n\\n<p style=\\\"text-align:right;direction:rtl;\\\">השעון שלנו בתרגיל זה הוא שעון 24 שעות בפורמט HH:MM.<\\/p>\\n<p style=\\\"text-align:right;direction:rtl;\\\">תחילה, כתבו פונקציה המקבלת את השעה בפורמט HH:MM, ומקבלת את מספר השעות שיש להוסיף או להוריד מהשעה הנתונה, ומחזירה את השעה המעודכנת.<\\/p><br>\\n<code>time_shift(\\\"08:44\\\", 1)<\\/code><br>\\n<samp style=\\\"text-align:left;direction:ltr;\\\">\\\"09:44\\\"<\\/samp><br>\\n<code>time_shift(\\\"07:31\\\", -2)<\\/code><br>\\n<samp>\\\"05:31\\\"<\\/samp>\\n<p style=\\\"text-align:right;direction:rtl;\\\">כמו כן עליכם לוודא שמוכנסת שעה חוקית, ולהדפיס שגיאה אם לא:<\\/p><br>\\n<code>time_shift(\\\"32:12\\\", 4)<\\/code><br>\\n<samp>\\\"Invalid time inserted\\\"<\\/samp>\\n<p style=\\\"text-align:right;direction:rtl;\\\">נוסף לכך, עליכם לתמוך במעברים בין יממות. כלומר עליכם לבצע נכון פעולות מסוג זה:<\\/p><br>\\n<code>time_shift(\\\"23:30\\\", 2)<\\/code><br>\\n<samp>\\\"01:30\\\"<\\/samp><br>\\n<code>time_shift(\\\"04:13\\\", -5)<\\/code><br>\\n<samp>\\\"23:13\\\"<\\/samp>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# כתבו את הפונקציה שלכם כאן\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"12. 1列目をcol1.txtに，2列目をcol2.txtに保存\\n各行の1列目だけを抜き出したものをcol1.txtに,\\n2列目だけを抜き出したものをcol2.txtとしてファイルに保存せよ.\\n確認にはcutコマンドを用いよ.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncol1 = open('col1.txt', 'w')\\ncol2 = open('col2.txt', 'w')\\nhightemp = [i.replace('\\\\t', ' ').split() for i in open('hightemp.txt', 'r')]\\n\\ncol1.write(\\\"\\\\n\\\".join(map(str, [i[0] for i in hightemp])))\\ncol1.close()\\ncol2.write(\\\"\\\\n\\\".join(map(str, [i[1] for i in hightemp])))\\ncol2.close()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<h1>Logging in to a web server<\\/h1>\\n\\n<h2>Get username and password<\\/h2>\\n<li>Best to store in a file for reuse\\n<li>You will need to set up your own login and password and place them in a file called wikidata.txt\\n<li>Line one of the file should contain your username\\n<li>Line two your password\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nwith open('wikidata.txt') as f:\\n    contents = f.read().split('\\\\n')\\n    username = contents[0]\\n    password = contents[1]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%sql\\nSELECT STATION FROM CENTRAL_LINE\\n  WHERE REGEXP_LIKE(STATION,'(?:West)')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe following SQL is equivalent, except that the matched\\npattern is not kept for future use in matching.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Bipropagation_fashionMNIST.ipynb\\\".\\nThe first task is:\\nPreprocess the data\\nThe data must be preprocessed before training the network. If you inspect the first image in the training set, you will see that the pixel values fall in the range of 0 to 255:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nplt.figure()\\nplt.imshow(train_images[0])\\nplt.colorbar()\\nplt.grid(False)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"And Bob calculates $A^b \\\\bmod p$:\\n\",\"targets\":\"shared_secret_bob = pow(alice_to_bob, b, p)\\nprint(shared_secret_bob)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create a Baseline DNN Model in Keras\\nNow let's build the Deep Neural Network (DNN) model in Keras using the functional API. Unlike the sequential API, we will need to specify the input and hidden layers.  Note that we are creating a linear regression baseline model with no feature engineering. Recall that a baseline model is a solution to a problem without applying any machine learning techniques.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Build a simple Keras DNN using its Functional API\\ndef rmse(y_true, y_pred):  # Root mean square error\\n    return tf.sqrt(tf.reduce_mean(tf.square(y_pred - y_true)))\\n\\n\\ndef build_dnn_model():\\n    # input layer\\n    inputs = {\\n        colname: layers.Input(name=colname, shape=(), dtype='float32')\\n        for colname in NUMERIC_COLS\\n    }\\n\\n    # feature_columns\\n    feature_columns = {\\n        colname: fc.numeric_column(colname)\\n        for colname in NUMERIC_COLS\\n    }\\n\\n    # Constructor for DenseFeatures takes a list of numeric columns\\n    dnn_inputs = layers.DenseFeatures(feature_columns.values())(inputs)\\n\\n    # two hidden layers of [32, 8] just in like the BQML DNN\\n    h1 = layers.Dense(32, activation='relu', name='h1')(dnn_inputs)\\n    h2 = layers.Dense(8, activation='relu', name='h2')(h1)\\n\\n    # final output is a linear activation because this is regression\\n    output = layers.Dense(1, activation='linear', name='fare')(h2)\\n    model = models.Model(inputs, output)\\n\\n    # compile model\\n    model.compile(optimizer='adam', loss='mse', metrics=[rmse, 'mse'])\\n\\n    return 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 \\\"0.24\\/_downloads\\/c1dad3cf15579a4724c19d6df916b111\\/mixed_norm_inverse.ipynb\\\".\\nThe first task is:\\nCompute sparse inverse solution with mixed norm: MxNE and irMxNE\\nRuns an (ir)MxNE (L1\\/L2 :footcite:GramfortEtAl2012 or L0.5\\/L2\\n:footcite:StrohmeierEtAl2014 mixed norm) inverse solver.\\nL0.5\\/L2 is done with irMxNE which allows for sparser source estimates with less\\namplitude bias due to the non-convexity of the L0.5\\/L2 mixed norm penalty.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Author: Alexandre Gramfort <alexandre.gramfort@inria.fr>\\n#         Daniel Strohmeier <daniel.strohmeier@tu-ilmenau.de>\\n#\\n# License: BSD-3-Clause\\n\\nimport numpy as np\\n\\nimport mne\\nfrom mne.datasets import sample\\nfrom mne.inverse_sparse import mixed_norm, make_stc_from_dipoles\\nfrom mne.minimum_norm import make_inverse_operator, apply_inverse\\nfrom mne.viz import (plot_sparse_source_estimates,\\n                     plot_dipole_locations, plot_dipole_amplitudes)\\n\\nprint(__doc__)\\n\\ndata_path = sample.data_path()\\nfwd_fname = data_path + '\\/MEG\\/sample\\/sample_audvis-meg-eeg-oct-6-fwd.fif'\\nave_fname = data_path + '\\/MEG\\/sample\\/sample_audvis-ave.fif'\\ncov_fname = data_path + '\\/MEG\\/sample\\/sample_audvis-shrunk-cov.fif'\\nsubjects_dir = data_path + '\\/subjects'\\n\\n# Read noise covariance matrix\\ncov = mne.read_cov(cov_fname)\\n# Handling average file\\ncondition = 'Left Auditory'\\nevoked = mne.read_evokeds(ave_fname, condition=condition, baseline=(None, 0))\\nevoked.crop(tmin=0, tmax=0.3)\\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\":\"As expected, from a certain smoothness (3 x voxel size), the distribution remains the same.\\nFirst: the distribution without smoothness!\\nThe RF with smoothness 0 should be just normally distributed values without correlation.  The peaks with smoothness 0 should be just maxima of a sample of normally distributed values.  We know the distribution of a sample with normally distribution values from order statistics:\\n$f_{max}(x) = nF(x)^{n-1}f(x)$\\nThis is to show that the distribution of the maximum of the sample is the right one.\\n\\nSimulate n normally distributed values\\nTake the maximum\\nCompute for a range of values the distribution of the maximum\\nShow histogram of simulated maxima with the pdf on top\\n\",\"targets\":\"# random sample\\n\\nsmplm = []\\n\\nfor i in range(100000):\\n    smpl = np.random.standard_normal((n,))\\n    smplm.append(max(smpl))\\n\\n# distribution\\n\\nxm = np.arange(-1,5,0.001)\\nym = n*stats.norm.cdf(xm)**(n-1)*stats.norm.pdf(xm)\\n\\n# histogram\\n\\ntwocol=cb.qualitative.Paired_10.mpl_colors\\nplt.figure(figsize=(6,3))\\nax=plt.subplot(111)\\nax.hist(smplm,100,normed=1,facecolor=twocol[0],alpha=0.75,lw=0)\\nax.plot(xm,ym,color=twocol[1],lw=3)\\nax.set_xlim([-1,5])\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Download the data and preview\\n!gsutil cp gs:\\/\\/ml-design-patterns\\/fraud_data_kaggle.csv .\\n\\nfraud_data = pd.read_csv('fraud_data_kaggle.csv')\\nfraud_data.head()\\n\\n# Drop a few columns we won't use for this demo\\nfraud_data = fraud_data.drop(columns=['nameOrig', 'nameDest', 'isFlaggedFraud'])\\nfraud_data = pd.get_dummies(fraud_data)\\n\\n# Split into separate dataframes\\nfraud = fraud_data[fraud_data['isFraud'] == 1]\\nnot_fraud = fraud_data[fraud_data['isFraud'] == 0]\\n\\n# Take a random sample of non-fraud data\\n# The .005 frac will give us around an 80\\/20 split of not-fraud\\/fraud samples\\n# You can experiment with this value\\nnot_fraud_sample = not_fraud.sample(random_state=2, frac=.005)\\n\\n# Put the data back together and shuffle\\nfraud_data = pd.concat([not_fraud_sample,fraud])\\nfraud_data = shuffle(fraud_data, random_state=2)\\n\\n# Look at our data balance after downsampling\\nfraud_data['isFraud'].value_counts()\\n\\ntrain_test_split = int(len(fraud_data) * .8)\\n\\ntrain_data = fraud_data[:train_test_split]\\ntest_data = fraud_data[train_test_split:]\\n\\ntrain_labels = train_data.pop('isFraud')\\ntest_labels = test_data.pop('isFraud')\\n\\nmodel = xgb.XGBRegressor(\\n    objective='reg:linear'\\n)\\n\\nmodel.fit(train_data.values, train_labels)\\n\\n# Get some test predictions\\ny_pred = model.predict(test_data.values)\\n\\n# To build a confusion matrix using the scikit utility, we'll need the values as ints\\ny_pred_formatted = []\\n\\nfor i in y_pred:\\n  y_pred_formatted.append(int(round(i)))\\n\\ncm = confusion_matrix(test_labels.values, y_pred_formatted)\\nprint(cm)\\n\\n# This is from the sklearn docs\\n# https:\\/\\/scikit-learn.org\\/0.18\\/auto_examples\\/model_selection\\/plot_confusion_matrix.html\\ndef plot_confusion_matrix(cm, classes,\\n                          normalize=False,\\n                          title='Confusion matrix',\\n                          cmap=plt.cm.Blues):\\n    \\\"\\\"\\\"\\n    This function prints and plots the confusion matrix.\\n    Normalization can be applied by setting `normalize=True`.\\n    \\\"\\\"\\\"\\n    plt.imshow(cm, interpolation='nearest', cmap=cmap)\\n    plt.title(title)\\n   ...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nDownsampling\\nTo demonstrate downsampling, we'll be using this synthetic fraud detection dataset from Kaggle. We've made a version of it available in a public Cloud Storage bucket.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%px --local\\ndef resize_method(filename, method):\\n    filepath = os.path.join(src_dir, filename)\\n    im = Image.open(filepath)\\n    resized_im = im.resize((hsize, vsize), method)\\n    resized_filepath = os.path.join(trg_dir, prefix + filename)\\n    resized_im.save(resized_filepath, \\\"JPEG\\\", quality = 100)\\n\\ndef resize_NEAREST(filename):\\n    resize_method(filename, Image.NEAREST)\\n\\ndef resize_LANCZOS(filename):\\n    resize_method(filename, Image.LANCZOS)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLet us define functions that do the above in one go for all files:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"1. Write the simulation which determine if in one round of replication HIV will mutate or not\\n\",\"targets\":\"# Set the states (mutation,no_mutation)\\n\\n# Set the probabilities\\n\\n# flip the coin (make the choice)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# GRADED FUNCTION: normalizeRows\\n\\ndef normalizeRows(x):\\n    \\\"\\\"\\\"\\n    Implement a function that normalizes each row of the matrix x (to have unit length).\\n    \\n    Argument:\\n    x -- A numpy matrix of shape (n, m)\\n    \\n    Returns:\\n    x -- The normalized (by row) numpy matrix. You are allowed to modify x.\\n    \\\"\\\"\\\"\\n    \\n    ### START CODE HERE ### (≈ 2 lines of code)\\n    # Compute x_norm as the norm 2 of x. Use np.linalg.norm(..., ord = 2, axis = ..., keepdims = True)\\n    x_norm = np.linalg.norm(x, ord = 2, axis = 1, keepdims = True)\\n    \\n    # Divide x by its norm.\\n    x = x\\/x_norm\\n    ### END CODE HERE ###\\n\\n    return x\\n\\nx = np.array([\\n    [0, 3, 4],\\n    [1, 6, 4]])\\nprint(\\\"normalizeRows(x) = \\\" + str(normalizeRows(x)))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExpected Output: \\n<table style=\\\"width:100%\\\">\\n     <tr> \\n       <td> **image2vector(image)** <\\/td> \\n       <td> [[ 0.67826139]\\n [ 0.29380381]\\n [ 0.90714982]\\n [ 0.52835647]\\n [ 0.4215251 ]\\n [ 0.45017551]\\n [ 0.92814219]\\n [ 0.96677647]\\n [ 0.85304703]\\n [ 0.52351845]\\n [ 0.19981397]\\n [ 0.27417313]\\n [ 0.60659855]\\n [ 0.00533165]\\n [ 0.10820313]\\n [ 0.49978937]\\n [ 0.34144279]\\n [ 0.94630077]]<\\/td> \\n     <\\/tr>\\n\\n\\n<\\/table>\\n\\n1.4 - Normalizing rows\\nAnother common technique we use in Machine Learning and Deep Learning is to normalize our data. It often leads to a better performance because gradient descent converges faster after normalization. Here, by normalization we mean changing x to $ \\\\frac{x}{\\\\| x\\\\|} $ (dividing each row vector of x by its norm).\\nFor example, if $$x = \\n\\\\begin{bmatrix}\\n    0 & 3 & 4 \\\\\\n    2 & 6 & 4 \\\\\\n\\\\end{bmatrix}\\\\tag{3}$$ then $$\\\\| x\\\\| = np.linalg.norm(x, axis = 1, keepdims = True) = \\\\begin{bmatrix}\\n    5 \\\\\\n    \\\\sqrt{56} \\\\\\n\\\\end{bmatrix}\\\\tag{4} $$and        $$ x_normalized = \\\\frac{x}{\\\\| x\\\\|} = \\\\begin{bmatrix}\\n    0 & \\\\frac{3}{5} & \\\\frac{4}{5} \\\\\\n    \\\\frac{2}{\\\\sqrt{56}} & \\\\frac{6}{\\\\sqrt{56}} & \\\\frac{4}{\\\\sqrt{56}} \\\\\\n\\\\end{bmatrix}\\\\tag{5}$$ Note that you can divide matrices of different sizes and it works fine: this is called broadcasting and you're going to learn about it in part 5.\\nExercise: Implement normalizeRows() to normalize the rows of a matrix. After applying this function to an input matrix x, each row of x should be a vector of unit length (meaning length 1).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<h4>datetime objects can check validity<\\/h4>\\n<li>A ValueError exception is raised if the object is invalid<\\/li>\\n\",\"targets\":\"some_date=datetime.date(2015,2,29)\\n#some_date =datetime.date(2016,2,29)\\n#some_time=datetime.datetime(2015,2,28,23,60,0)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Character histogram\\nhttps:\\/\\/www.careercup.com\\/question?id=4535655694598144\\nYou have the file with word at a single line. \\ninput sample file\\nabactor \\nabaculus \\nabacus \\nAbadite \\n. \\n. \\nZyrenian\\nOutput\\n******************************************************************a \\n*************b \\n**********************************c \\n**********************d \\n*******************************************************************************e\\nCharacter histogram\\n\\nyou have to count the character and create a histogram in alphabetical order. \\nnow you have to produce a histogram with max 80 character in line in reference to max count \\nnow same out based histrogram based on the character count\\n\",\"targets\":\"def generate_histogram(texts, width):\\n    letters = {}\\n    m = None\\n    for t in texts:\\n        for c in t.lower():\\n            letters[c] = letters.get(c, 0) + 1\\n            if m is None or letters[c] > m:\\n                m = letters[c]\\n    \\n    for i in range(ord(\\\"a\\\"), ord(\\\"z\\\") + 1):\\n        if chr(i) in letters:\\n            n = int(letters[chr(i)] * width \\/ m)\\n            print(\\\"*\\\" * n + chr(i))\\ngenerate_histogram([\\\"aaaaaaaaaabbbbbcccdderrrkkkkk\\\"], 80)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"DefensiveProgramming_3.ipynb\\\".\\nThe first task is:\\nAnd test it...\\nCan you write Python code for it?\\n\",\"targets\":\"\\ntest_range_overlap()\\n\\ntest_range_overlap_one_range()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"00_Python_Crash_Course.ipynb\\\".\\nThe first task is:\\nHere, the 3rd element of a has been changed to 17.  Now let's check on b.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nb\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# PROMPT 9 - write function\\n\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nStep 1.c: Refactor into a function getDirections()\\nNow the we understand the API, let's refactor the code into a useable function \\nFUNCTION INPUTS:\\nPROMPT 5\\n\\nFUNCTION OUTPUTS:\\nPROMPT 6\\n\\nALGORITHM:\\nPROMPT 7\\n\\nTEST (How do we know it's right?)\\nPROMPT 8\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Another useful method is the .intersection(...) that returns the records that are equal in both RDDs.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nrdd5 = rdd1.intersection(rdd2)\\nrdd5.collect()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Build the Neural Network\\nWe'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\\nThe model_inputs() function creates TF Placeholders for the Neural Network. It would 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\\nReturns 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\\n    inputs = tf.placeholder(tf.int32, [None, None], name='input')\\n    targets = tf.placeholder(tf.int32, [None, None], name='targets')\\n    learning_rate = tf.placeholder(tf.float32, name='learning_rate')\\n    keep_prob = tf.placeholder(tf.float32, name='keep_prob')\\n    return inputs, targets, learning_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\":\"Cool example of using sparklines from Peter Baumgartner\\nhttps:\\/\\/twitter.com\\/pmbaumgartner\\/status\\/1084645440224559104\\n\",\"targets\":\"def sparkline_str(x):\\n    bins=np.histogram(x)[0]\\n    sl = ''.join(sparklines(bins))\\n    return sl\\nsparkline_str.__name__ = \\\"sparkline\\\"\\n\\ndf.groupby('name')['quantity', 'ext price'].agg(['mean', sparkline_str])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Heater Calibration Tests.ipynb\\\".\\nThe first task is:\\nOnce $m$ and $c$ have been calculated in the calibrate function, we have to make a preadjustment function, which is given by:\\n$$ preadjustment(x) := \\\\frac{x - c}{m} $$\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef error_correction_function(heater_current, measurements):\\n    m, c, r_value, p_value, std_err = calibrate(heater_current, measurements)\\n    return (lambda x: (x - c) \\/ m)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Import 'make_scorer', 'DecisionTreeRegressor', and 'GridSearchCV'\\nfrom sklearn.metrics import make_scorer\\nfrom sklearn.tree import DecisionTreeRegressor\\nfrom sklearn import grid_search\\n\\ndef fit_model(X, y):\\n    \\\"\\\"\\\" Performs grid search over the 'max_depth' parameter for a \\n        decision tree regressor trained on the input data [X, y]. \\\"\\\"\\\"\\n    \\n    # Create cross-validation sets from the training data\\n    cv_sets = ShuffleSplit(X.shape[0], n_iter = 10, test_size = 0.20, random_state = 0)\\n\\n    # Create a decision tree regressor object\\n    regressor = DecisionTreeRegressor()\\n\\n    # Create a dictionary for the parameter 'max_depth' with a range from 1 to 10\\n    params = {'max_depth' : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}\\n\\n    # Transform 'performance_metric' into a scoring function using 'make_scorer' \\n    scoring_fnc = make_scorer(performance_metric)\\n\\n    # Create the grid search object\\n    grid = grid_search.GridSearchCV(regressor, params, cv=cv_sets, scoring=scoring_fnc) \\n\\n    # Fit the grid search object to the data to compute the optimal model\\n    grid = grid.fit(X, y)\\n\\n    # Return the optimal model after fitting the data\\n    return grid.best_estimator_\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nQuestion 5 - Bias-Variance Tradeoff\\nWhen the model is trained with a maximum depth of 1, does the model suffer from high bias or from high variance? How about when the model is trained with a maximum depth of 10? What visual cues in the graph justify your conclusions?\\nHint: How do you know when a model is suffering from high bias or high variance?\\nAnswer:  \\nWith a max depth of 1 the model suffers from high bias, because the model is not comlex enough which leads to low accuracy.\\nWith a max depth of 10 the model suffers from high variance, because the model was trained with too many details from the training set and it overfits their characteristics on the whole dataset. \\nWhen we a have a bias error - training and validation curves are drawn together, but with a very low accuracy score. High variance on the other hand looks like the curves with a max depth of 10: high accuracy score on a training data, low - on a whole dataset due to the overfitting. \\nQuestion 6 - Best-Guess Optimal Model\\nWhich maximum depth do you think results in a model that best generalizes to unseen data? What intuition lead you to this answer?\\nAnswer: \\nA model with a max_depth of 3 is the best among others, because it is very consistent in scoring on testing and validation data and also having the highest score (R squared) of around 0.8. Other models, especially the first and the last one are useless, as they can't predict data correctly at all (first has a huge bias, last has a huge variance).  \\n\\nEvaluating Model Performance\\nIn this final section of the project, you will construct a model and make a prediction on the client's feature set using an optimized model from fit_model.\\nQuestion 7 - Grid Search\\nWhat is the grid search technique and how it can be applied to optimize a learning algorithm?\\nAnswer: \\nGridSearch is a way of systematically working through multiple combinations of parameter tunes, cross-validating as it goes to determine which tune gives the best performance.\\nQuestion 8 - Cross-Validation\\nWhat is the k-fold...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"- needs to be escaped if we want to include it in the character range:\\n\",\"targets\":\"re.search(\\\"[0-9\\\\-]+\\\", \\\"1-2\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#@title Create fake dataset of adgroups and conversion values\\n#@markdown We are generating random data: each row is an individual conversion\\n#@markdown with a given conversion value. \\\\\\n#@markdown For each conversion, we know the\\n#@markdown adgroup, which is our only feature here and just consists of 3 letters.\\n\\nn_consenting_customers = 8000  #@param\\nn_nonconsenting_customers = 2000  #@param\\n\\n\\ndef simulate_conversion_data_consenting_non_consenting(\\n    n_consenting_customers: int,\\n    n_nonconsenting_customers: int) -> typing.Tuple[pd.DataFrame, pd.DataFrame]:\\n  \\\"\\\"\\\"Simulates dataframes for consenting and non-consenting customers.\\n\\n    Args:\\n      n_consenting_customers: Desired number of consenting customers. Should be\\n        larger than n_nonconsenting_customers.\\n      n_nonconsenting_customers: Desired number non non-consenting customers.\\n\\n    Returns:\\n      Two dataframes of simulated consenting and non-consenting customers.\\n  \\\"\\\"\\\"\\n  fake_adgroups = np.array(\\n      ['_'.join(fake_ad) for fake_ad in (combinations('ABCDEFG', 3))])\\n\\n  data_consenting = pd.DataFrame.from_dict({\\n      'adgroup':\\n          fake_adgroups[np.random.randint(\\n              low=0, high=len(fake_adgroups), size=n_consenting_customers)],\\n      'conversion_value':\\n          np.random.lognormal(1, size=n_consenting_customers)\\n  })\\n\\n  data_nonconsenting = pd.DataFrame.from_dict({\\n      'adgroup':\\n          fake_adgroups[np.random.randint(\\n              low=0, high=len(fake_adgroups), size=n_nonconsenting_customers)],\\n      'conversion_value':\\n          np.random.lognormal(1, size=n_nonconsenting_customers)\\n  })\\n  return data_consenting, data_nonconsenting\\n\\n\\ndata_consenting, data_nonconsenting = simulate_conversion_data_consenting_non_consenting(\\n    n_consenting_customers, n_nonconsenting_customers)\\ndata_consenting.head()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nData Simulation\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%time\\n\\ng2 = g.gremlin('g.E().limit(10000)')\\n\\n\\nprint('NODES:')\\ng2._nodes.info()\\ng2._nodes.sample(3)\\n\\nprint('EDGES:')\\nprint(g2._edges.info())\\n\\ng2._edges.sample(3)\\n\\n%%time\\n\\n# Enrich nodes dataframe with any available server property data\\n\\ng3 = g2.fetch_nodes()\\n\\nprint(g3._nodes.info())\\n\\ng3._nodes.sample(3)\\n\\n%%time\\n\\ng3.plot()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nQuery & plot\\n\\nPyGraphistry automatically converts gremlin results into node\\/edge dataframes\\nEdge queries typically only return node IDs; call fetch_nodes() to enrich your g._nodes dataframe\\nPyGraphistry plots dataframes\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"And here's the final temperature:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncoffee.T_final = get_last_value(results.T)\\nT_final = get_last_value(results.T)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Randomly select a record from the loaded test data.\\nsmple = fedata.sample(False, .8).limit(1).select(input_features)\\n\\nsmple.toPandas().head()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTest the functions\\nWe can then test the init() and run() functions right here in the notebook. It's about impossible to debug after publish a web service.\\nFirst we get a sample test observation that we can score. For this, we can randomly select a single record from the test data we've loaded from Azure blob.\",\"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\\/04 - Applied ML\\/Homework_04_Referees_teamawesome-Q1 + Bonus.ipynb\\\".\\nThe first task is:\\nIII. Random Forest\\nCan you write Python code for it?\\n\",\"targets\":\"\\n#Initialize\\nforest = RandomForestClassifier(n_estimators = 100)\\n\\n# Fit the training data and create the decision trees\\nforest = forest.fit(trainArr,trainRes_1)\\n\\n# Take the same decision trees and run it on the test data\\nData_Testing = Data_Simple5.sample(frac=0.2)\\nInput_Data_Testing = Data_Testing.drop(exclude, axis=1)\\ntestArr = Input_Data_Testing.as_matrix()\\nresults = forest.predict(testArr)\\n\\nData_Testing['predictions'] = results\\nData_Testing.head()\\n\\n#see percentage of right predictions\\ncorrect = list(Data_Testing[Data_Testing['raterScale'] == Data_Testing['predictions']].index)\\nA = len(correct)\\npercCorrect = A\\/Data_Testing['raterScale'].size\\npercCorrect\",\"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.0\\/tutorials\\/pblum.ipynb\\\".\\nThe first task is:\\nLet's see how changing the value of pblum affects the computed light curve.  By default, pblum is set to be 4 pi, giving a total flux for the primary star of ~1.\\nSince the secondary star in the default binary is identical to the primary star, we'd expect an out-of-eclipse flux of the binary to be ~2.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nb.run_compute()\\n\\naxs, artists = b.plot(dataset='lc01')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# remove the BigQuery dataset created for storing the recommendations and all of its tables\\n! bq rm -r -f -d $PROJECT:$DATASET\\n\\n# remove the Cloud Storage bucket created and all of its tables\\n! gsutil rm -r gs:\\/\\/$BUCKET_NAME\\n\\n# delete the created Dataproc cluster\\n! gcloud dataproc clusters delete $CLUSTER_NAME --region=$CLUSTER_REGION\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nClean up\\n<a name=\\\"section-12\\\"><\\/a>\\nTo clean up all Google Cloud resources used in this project, you can delete the Google Cloud\\nproject you used for the tutorial.\\nOtherwise, you can delete the individual resources you created in this tutorial:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Above, we created a new transform primitive that can be used with Deep Feature Synthesis by deriving a new primitive class using TransformPrimitive as a base and overriding get_function to return a function that calculates the feature. Additionally, we set the input data types that the primitive applies to and the return data type. Input and return data types are defined using a Woodwork ColumnSchema. A full guide on Woodwork logical types and semantic tags can be found in the Woodwork Understanding Types and Tags guide.\\nSimilarly, we can make a new aggregation primitive using AggregationPrimitive.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nclass Maximum(AggregationPrimitive):\\n    name = 'maximum'\\n    input_types = [ColumnSchema(semantic_tags={'numeric'})]\\n    return_type = ColumnSchema(semantic_tags={'numeric'})\\n\\n    def get_function(self):\\n        def maximum(column):\\n            return max(column)\\n\\n        return maximum\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Prepare analysis data.ipynb\\\".\\nThe first task is:\\nSame tweet belongs to multiple datasets\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf_merged_meta.t_id.value_counts().head()\\n\\ndf_merged_meta[df_merged_meta.t_id == 700042121877835776][[\\\"topic_name\\\"]]\\n\\ndf_merged_meta.t_id.value_counts()[df_merged_meta.t_id.value_counts() > 1]\\n\\ndf_merged_meta[df_merged_meta.t_id == 792354716521009152].T\\n\\ndf_merged_meta[\\\"is_controversial\\\"] = df_merged_meta.topic_name.isin(CONTROVERSIAL_TOPICS)\\ndf_merged_meta.is_controversial.value_counts()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Bias\\nHere we show that the MLE estimator is unbiased, i.e., that the expected value for the MLE estimate for a parameter is the true value. The expected value is the average over many (-> inf) observations of the same process.\\n\",\"targets\":\"# Now repeat the whole analysis (from data generation on) a certain number of times\\n\\n# I prepared a convenience function to do that. \\n# This function regenerates some data from the same generative process\\n# used above, then it fits them and returns the list of MLE estimates\\n# for a (one for each iteration)\\n# Let's do it 1000 times\\n\\nmany_a_mle = like.generate_and_fit(data_generative_process, 1000)\\n\\n# Now let's plot the MLEs for a\\n\\nplt.plot(many_a_mle,'.')\\nplt.ylabel(r\\\"a$_{MLE}$\\\")\\nplt.xlabel(\\\"iteration\\\")\\n\\n# Plot the true value\\nplt.axhline(a_true, color='red',lw=2,linestyle='--')\\n\\n# We can make an histogram of the MLE estimates\\nhistogram = plt.hist(many_a_mle, 20)\\nplt.xlabel(\\\"a\\\")\\n# plot the vertical like of the true value\\nplt.axvline(a_true, color='red', lw=2, linestyle='--', zorder=100)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# =============================\\n# change these (both in millis)\\ndelay_stream, slow_emit = 0, 0\\n# =============================\\n\\nimport rx, threading, random, time\\nthread = threading.currentThread\\n\\n\\ndef call_observer(obs):\\n    '''observer functions are invoked, blocking'''\\n    print_out(obs.__class__.__name__, hash(obs))\\n    for i in range(2):\\n        obs.on_next(1)\\n        if slow_emit:\\n            time.sleep(slow_emit\\/1000)\\n        obs.on_next(1)\\n        \\nstream = rx.Observable.create(call_observer).take(10)\\nif delay_stream:\\n    stream = stream.delay(delay_stream)\\n\\ndef print_out(*v):\\n    '''printout of current time, v, and current thread'''\\n    v_pretty = ' '.join([str(s) for s in v])\\n    print ('%.8f - %30s - %s\\\\n' % (time.time(), v_pretty, thread().getName()))\\n    \\n    \\nd = stream.subscribe(lambda x: print_out('Observer 1', x))\\nd = stream.subscribe(lambda x: print_out('Observer 2', x))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAsync Operations\\nIt is useful to understand on a high level how RxPY handles asyncronity and when.\\nE.g. naively you might want to know, when notifying a value to a subscriber, what other subscribers are present.\\nThis makes no sense to ask (I think in general in reactive programming) and it will be clear looking at an example.    \\nConsider timing and thread outputs in the following:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"!mkdir frames\\nframe = img\\nframe_i = 0\\n\\nh, w = frame.shape[:2]\\ns = 0.05 # scale coefficient\\n\\nfor i in xrange(1):\\n    frame = deepdream(net, frame)\\n    PIL.Image.fromarray(np.uint8(frame)).save(\\\"frames\\/%04d.jpg\\\"%frame_i)\\n    frame = nd.affine_transform(frame, [1-s,1-s,1], [h*s\\/2,w*s\\/2,0], order=1)\\n    frame_i += 1\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWhat if we feed the deepdream function its own output, after applying a little zoom to it? It turns out that this leads to an endless stream of impressions of the things that the network saw during training. Some patterns fire more often than others, suggestive of basins of attraction.\\nWe will start the process from the same sky image as above, but after some iteration the original image becomes irrelevant; even random noise can be used as the starting point.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Datasets\\/CLEU\\/.ipynb_checkpoints\\/CLEU-checkpoint.ipynb\\\".\\nThe first task is:\\nLimpieza de dataset para P0702: Restricción al paso de automóviles\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# La columna 'Restricción del paso a automóviles' clasifica las manzanas\\n# que tienen alguna clase de restriccion al paso de automóviles.\\nP0702_raw = datasets['P0702']\\nlist(P0702_raw['Restricción del paso a automóviles'].unique())\\n\\nP0702_raw.head()\\n\\nlist(P0702_raw)\\n\\n# Es conveniente crear un dataset con el total de manzanas por municipio\\nmanzanas = P0702_raw[P0702_raw['Restricción del paso a automóviles'] == 'Total']['Total de manzanas']\\nmanzanas.head()\\n\\n# Para el parametro, hay que filtrar unicamente las columnas que contienen restricciones a la vialidad\\nP0702_1 = P0702_raw.loc[P0702_raw['Restricción del paso a automóviles'].isin([\\n    'Restricción del paso a automóviles en todas las vialidades',\\n    'Restricción del paso a automóviles en alguna vialidad',\\n])]\\nP0702_1.head()\\n\\n# Una vez filtrados hay que agregar los datos por municipio. También vale la pena quitar las columnas de \\n# restriccion al paso de peatones, pues no son de interes para este parametro.\\nP0702_1 = P0702_1['Total de manzanas'].groupby(level=0).sum().to_frame(name='Restricción del paso a automóviles')\\nP0702_1.head()\\n\\n# Unimos ambos datasets para crear el dataset estandar del parámetro\\nP0702 = manzanas.to_frame().join(P0702_1)\\nprint(len(P0702))\\nP0702.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"$\\\\alpha$-$\\\\beta$ pruning with intelligent memoization takes 17 ms to compute the value of the state gStart for Tic-Tac-Toe. \\nHence, there is no big difference between intelligent memoization and naive memoization in this example.  However, if we implement\\na non-trivial game like Connect Four, the situation changes.\\n\",\"targets\":\"%%time\\nv = evaluate(gStart, maxValue, -1, 1)\\nv\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"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:\\nYeah... pretty bad. The neural network will have to learn to do better. First let's see if it is capable of learning the basic policy we used earlier: go left if the pole is tilting left, and go right if it is tilting right. The following code defines the same neural network but we add the target probabilities y, and the training operations (cross_entropy,  optimizer and training_op):\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport tensorflow as tf\\n\\nreset_graph()\\n\\nn_inputs = 4\\nn_hidden = 4\\nn_outputs = 1\\n\\nlearning_rate = 0.01\\n\\ninitializer = tf.variance_scaling_initializer()\\n\\nX = tf.placeholder(tf.float32, shape=[None, n_inputs])\\ny = tf.placeholder(tf.float32, shape=[None, n_outputs])\\n\\nhidden = tf.layers.dense(X, n_hidden, activation=tf.nn.elu, kernel_initializer=initializer)\\nlogits = tf.layers.dense(hidden, n_outputs)\\noutputs = tf.nn.sigmoid(logits) # probability of action 0 (left)\\np_left_and_right = tf.concat(axis=1, values=[outputs, 1 - outputs])\\naction = tf.multinomial(tf.log(p_left_and_right), num_samples=1)\\n\\ncross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=logits)\\noptimizer = tf.train.AdamOptimizer(learning_rate)\\ntraining_op = optimizer.minimize(cross_entropy)\\n\\ninit = tf.global_variables_initializer()\\nsaver = tf.train.Saver()\",\"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_1_Calibration_Least_Squares_Problem.ipynb\\\".\\nThe first task is:\\nThe images above contain the real part of the corrupted (green) and uncorrupted (blue)\\nvisibilities as a function of timeslots for baseline 01, 02 and 12 respectively.\\n8.1.4 Levenberg-Marquardt (create_G_LM) <a id='cal:sec:LM'><\\/a> <!--\\\\label{cal:sec:LM}-->\\nWe are now ready to use least squares to calibrate $\\\\boldsymbol{\\\\mathcal{D}}$ (see <cite data-cite='Yatawatta2012'>GPU accelerated nonlinear optimization in radio interferometric calibration<\\/cite> &#10548;).\\nWe first present a brief review of least squares minimization. Suppose we wish to fit a model $\\\\mathbf{f}\\\\left( \\\\mathbf{m},\\\\breve{\\\\mathbf{g}}\\\\right)$, where $\\\\mathbf{m}$ and $\\\\breve{\\\\mathbf{g}}$ denote\\nthe model input values and a vector of unknown variables respectively, to some data $\\\\left{\\\\mathbf{d}{i},\\\\mathbf{m}{i}\\\\right}$. The vector of unknown variables $\\\\breve{\\\\mathbf{g}}$ parametrize the model. A standard method for determining which parameter vector $\\\\breve{\\\\mathbf{g}}$ best fits the data is to minimize the sum of the squared residuals. This technique is referred to as least squares minimization. The residual vector is denoted by $\\\\mathbf{r}(\\\\mathbf{m},\\\\mathbf{d},\\\\breve{\\\\mathbf{g}}) = \\\\mathbf{d} - \\\\mathbf{f}\\\\left( \\\\mathbf{m},\\\\breve{\\\\mathbf{g}}\\\\right)$. The objective function (the function we wish to minimize) associated with least squares is: $\\\\sum_i \\\\mathbf{r}_i^2$. The function optimize.leastsq is scipy's built-in least squares solver and employs the Levenberg-Marquardt algorithm in the background. The Levenberg-Marquardt algorithm is discussed in more detail in $\\\\S$ 2.11 &#10142;. To use optimize.leastsq one needs a function, here called err_func, that calculates the residual vector $\\\\mathbf{r}$. An initial guess of the parameter vector $\\\\breve{\\\\mathbf{g}}$ is also required.\\nFor calibration the above variables become:\\n<p class=conclusion>\\n  <font size=4> <b>Vectorizing<\\/b><\\/font>\\n  <br>\\n  <br>\\n&bull; $\\\\mathbf{d} = [\\\\textrm{vec}(\\\\Re\\\\{\\\\boldsymbol{\\\\mathcal{D}}\\\\}),\\\\textrm{vec}(\\\\Im\\\\{\\\\boldsymbol{\\\\mathcal{D}}\\\\})]$ <br><br>\\n&bull; $\\\\mathbf{m} =...\\nCan you write Python code for it?\\n\",\"targets\":\"\\n'''Unpolarized direction independent calibration entails finding the G that minimizes ||R-GMG^H||. \\nThis function evaluates D-GMG^H.\\ng is a vector containing the real and imaginary components of the antenna gains.\\nd is a vector containing a vecotrized R (observed visibilities), real and imaginary.\\nm is a vector containing a vecotrized M (predicted), real and imaginary.\\nr is a vector containing the residuals.\\n''' \\ndef err_func(g,d,m):\\n    Nm = len(d)\\/2\\n    N = len(g)\\/2\\n    G = np.diag(g[0:N]+1j*g[N:])\\n    D = np.reshape(d[0:Nm],(N,N))+np.reshape(d[Nm:],(N,N))*1j #matrization\\n    M = np.reshape(m[0:Nm],(N,N))+np.reshape(m[Nm:],(N,N))*1j\\n    T = np.dot(G,M)\\n    T = np.dot(T,G.conj())\\n    R = D - T\\n    r_r = np.ravel(R.real) #vectorization\\n    r_i = np.ravel(R.imag)\\n    r = np.hstack([r_r,r_i])\\n    return r\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Backtesting on real market data\\nThis is all very interesting but not very applied. We next demonstrate how you can create a simple algorithm in zipline -- the open-source backtester that powers Quantopian -- to test this optimization on actual historical stock data.\\nFirst, lets load in some historical data using Quantopian's data (if we are running in the Quantopian Research Platform, or the load_bars_from_yahoo() function from zipline.\\n\",\"targets\":\"from zipline.utils.factory import load_bars_from_yahoo\\nend = pd.Timestamp.utcnow()\\nstart = end - 2500 * pd.tseries.offsets.BDay()\\n\\ndata = load_bars_from_yahoo(stocks=['IBM', 'GLD', 'XOM', 'AAPL', \\n                                    'MSFT', 'TLT', 'SHY'],\\n                            start=start, end=end)\\n\\ndata.loc[:, :, 'price'].plot(figsize=(8,5))\\nplt.ylabel('price in $')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Example\\/LCCM code example.ipynb\\\".\\nThe first task is:\\nModify variables, create dummy variables,and scale variables so the estimated coefficients are of similar magnitudes.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Create a dummy variable indicating whether a certain individual in the sample is male or female\\ndf['male'] = (df['Gender']==1).astype(int)\\n\\n# Create a categorical variable to indicate the income level of the household corresponding to each individual\\n# in the sample. We will define three categories: low income (income category  < 6) , medium income\\n# (6 <= income category < 12) and high income (12 <= income category < 16). \\ndf['low_income'] = (df['HHIncome']<6).astype(int)\\ndf['medium_income'] = ((df['HHIncome']>=6)&(df['HHIncome']<12)).astype(int)\\ndf['high_income'] = ((df['HHIncome']>=12)&(df['HHIncome']<16)).astype(int)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Agora só temos um bloco-if com  duas instruções. O último print é executado porque a condição só controla a execução das duas intruções que estão no bloco.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nx=1\\n\\nif x>2:\\n    print(10*'.^.')\\nprint('O número é maior que 2.')\\nprint(10*'\\\\'v\\\\'')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<p style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\n    ורק בשביל הכיף, נבנה קוד שיאפשר לנו להשתמש במפה כדי להצפין מסרים:\\n<\\/p>\\n\",\"targets\":\"def encrypt(message, encryption_map):\\n    encrypted = ''\\n    for char in message.lower():\\n        # If we can't find the character, assume it is not encrypted.\\n        encrypted = encrypted + encryption_map.get(char, char)\\n    return encrypted\\n\\nencryption_map = get_ceaser_map()\\nencrypted_message = encrypt('This is the encrypted message!', encryption_map)\\nprint(encrypted_message)\\n\\ndef create_decryption_map(encryption_map):\\n    \\\"\\\"\\\"Actually just flip the keys and the values of the dictionary\\\"\\\"\\\"\\n    decryption_map = {}\\n    for key, value in encryption_map.items():\\n        decryption_map[value] = key\\n    return decryption_map\\n\\ndef decrypt(message, decryption_map):\\n    decrypted = ''\\n    for char in message.lower():\\n        # If we can't find the character, assume it is not encrypted.\\n        decrypted = decrypted + decryption_map.get(char, char)\\n    return decrypted\\n\\ndecryption_map = create_decryption_map(encryption_map)\\ndecrypted_message = decrypt(encrypted_message, decryption_map)\\nprint(decrypted_message)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#truncate to top 5\\nfor tup in top_nz_titles[:5]:\\n    print 'Title :', tup[0]\\n    print 'Title :', tup[1]\\n    try:\\n        poster = Image(nz_data[quote(tup[0])]['Poster'])\\n        display(poster)\\n    except:\\n        print '''\\n        |\\n        | No Poster\\n        |       \\n        '''\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe could potentially display this visually.\\nWe need to do some trickery as our dictionaries have quoted title names as the keys, so 'The%20Pink%20Panther' instead of 'The Pink Panther', so we need to 'quote' our moviename to get an image.\\nTop NZ Title Visually\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create a test value of a directional text\\n\",\"targets\":\"dir_str = 'SOUTH SOUTH EAST'\\nprint(dir_str)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Funciones Booleanas\\/Boole.ipynb\\\".\\nThe first task is:\\nLa formas normales conjuntiva y disyuntivas las podemos calcular como sigue\\nCan you write Python code for it?\\n\",\"targets\":\"\\nto_cnf(p)\\n\\nto_dnf(p)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"'Top 10' Contratos de 2017\\nAgora com a lista de todos os contratos do ano, vamos montar uma tabela e ordenar os dados pelo Valor Principal do Contrato. No Manual da API, aprende-se que esse campo 'valPrincipal'significa o \\\"Valor do contrato sem ocorrência de reajustamentos, ou aditamentos\\\".\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntop10 = df_contratos_empenhados[['txtDescricaoModalidade',\\n                                 'txtObjetoContrato',\\n                                 'txtRazaoSocial',\\n                                 'numCpfCnpj',\\n                                 'valPrincipal']].sort_values(['valPrincipal'], ascending=False)[:10]\\n\\ntop10\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2.1 Using plt.plot to plot lines\\nBefore we get to plotting the percentage difference in stock prices. Let's get a feel of how to plot lines in matplotlib. Like a scatterplot, to plot lines we: \\n  * Pass an array of x-coordinates and y-coordinates to the first and second arguments of plt.plot. \\n  * If we do not pass any other arguments, plt.plot thinks that you want to plot a line graph.\\n\",\"targets\":\"# Use this space to do the following: Plot a simple line graph using plt.plot. Use the data below.\\n\\nxcoord = [1,2,3,4]\\nycoord = [5, -3, 9, -1]\\n\\n# Answer:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<h2>13.Area of Figures<\\/h2>\\n\\nWrite a program that introduces the dimensions of a geometric figure and calculates its face.\\nThe figures are four types: a square, a rectangle, a circle, and a triangle.\\nOn the first line of the input reads the shape of the figure (square, rectangle, circle or triangle).\\nIf the figure is a square, the next line reads one number- the length of its country.\\nIf the figure is a rectangle, the next one two lines read two numbers- the lengths of his sides.\\nIf the figure is a circle, the next line reads one number\\nthe radius of the circle.\\nIf the figure is a triangle, the next two lines read two numbers - the length of the\\nits side and the length of the height to it. Score to round to 3 digits after the decimal  point.\\n\",\"targets\":\"import math\\n\\nfigure = input()\\n\\n\\nif figure == \\\"square\\\":\\n    side = float(input())\\n\\n    area = side ** 2\\n\\n    print(format(area,'.3f'))\\n\\nelif figure == \\\"rectangle\\\":\\n    side_a = float(input())\\n    side_b = float(input())\\n\\n    area = side_a * side_b\\n\\n    print(format(area,'.3f'))\\n\\nelif figure == \\\"circle\\\":\\n     radius = float(input())\\n\\n     area = radius ** 2 * math.pi\\n\\n     print(format(area,'.3f'))\\n\\n\\nelif figure == \\\"triangle\\\":\\n    side = float(input())\\n    height = float(input())\\n\\n    area = (side * height) \\/ 2\\n\\n    print(format(area,'.3f'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Code Documentation\\nAstro Hack Week 2017\\nThe notebook contains problems for documenting code.\\nThese probablems assume you've done the \\\"code repo\\\" problem set, or otherwise are familiar with code repositories and packaging enough to have a functioning test repository with a Python package.\\n\\nE Tollerud, B Sipocz\\nProblem 1: Making and using docstrings\\nOne of Python's most powerful documentation tools are docstrings.  These are basically just little strings you put at the top of a class, function, or similar, which then gets bound as sort of a glorified comment.  But with internal consistency and tenacity, these can do most of the work you need to document your code.\\nNote that all of this problem can be done in the notebook, and it is shown that way to make the notebook internally consistent.  But you might find it more useful to use a function from your code repository, as that makes it clearer why docstrings are useful (i.e., the code is not immediately visible, as it is in the notebook).\\n1a: Create a function with a docstring\\nMake a function (or just use one from your pre-existing repo) and give it a docstring.   The docstring can be anything in principal, but the example case below shows one of the most standard conventions used for scientific Python code. (The format originated in numpy, although with some \\\"flavors\\\" like that in astropy.)\\nHint: you might want to keep the code part of your function secret from your neighbor, as it will reduce the work for 1c if you do so\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef do_something(arg1, arg2):\\n    \\\"\\\"\\\"\\n    A short sentence describing what this function does.\\n    \\n    More description\\n    \\n    Parameters\\n    ----------\\n    arg1 : type1\\n        Description of the parameter ``arg1``\\n    arg2 : type2\\n        Description of the parameter ``arg2``\\n        \\n    Returns\\n    -------\\n    type of return value (e.g. int, float, string, etc.)\\n        A description of the thing the function returns (if anything)\\n    \\\"\\\"\\\" # complete\\n    # complete\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Autumn2017\\/02-Python-and-Data\\/Lecture-Python-And-Data-Completed.ipynb\\\".\\nThe first task is:\\nNote: strings in Python can be defined either with double quotes or single quotes\\nViewing Pandas Dataframes\\nThe head() and tail() methods show us the first and last rows of the data\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndata.head()\\n\\ndata.tail()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#@title Sementic search\\n#@markdown Enter a set of words to find matching sentences. 'results_returned' can beused to modify the number of matching sentences retured. To view the code behind this cell, use the menu in the top right to unhide...\\nsearch_string = \\\"code of ethics\\\" #@param {type:\\\"string\\\"}\\nresults_returned = \\\"3\\\" #@param [1, 2, 3]\\n\\nfrom sklearn.metrics.pairwise import cosine_similarity\\n\\n\\nembeddings2 = embed(\\n    [search_string],\\n    signature=\\\"default\\\",\\n    as_dict=True)[\\\"default\\\"]\\n\\nwith tf.Session() as sess:\\n  sess.run(tf.global_variables_initializer())\\n  sess.run(tf.tables_initializer())\\n  search_vect = sess.run(embeddings2)\\n  \\n\\ncosine_similarities = pd.Series(cosine_similarity(search_vect, x).flatten())\\noutput =\\\"\\\"\\nfor i,j in cosine_similarities.nlargest(int(results_returned)).iteritems():\\n  output +='<p style=\\\"font-family:verdana; font-size:110%;\\\"> '\\n  for i in sentences[i].split():\\n    if i.lower() in search_string:\\n      output += \\\" <b>\\\"+str(i)+\\\"<\\/b>\\\"\\n    else:\\n      output += \\\" \\\"+str(i)\\n  output += \\\"<\\/p><hr>\\\"\\n    \\noutput = '<h3>Results:<\\/h3>'+output\\ndisplay(HTML(output))\\n#   print(sentences[i])\\n#   print('\\\\n')\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCreate a semantic search engine:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Bootstrap Median Differences\\nhttp:\\/\\/faculty.psy.ohio-state.edu\\/myung\\/personal\\/course\\/826\\/bootstrap_hypo.pdf\\nBetween groups\\n\",\"targets\":\"## Pilot vs Controls d'\\ndp_pilot_controls = dict()\\n\\nstim_key = 'ss_us'\\ndiffs = [x - y for x in pilot_dprimes[stim_key] for y in controls_dprimes[stim_key]]\\ndp_pilot_controls[stim_key] = bayes_bootstrap(diffs, scipy.median, 1000, len(diffs))\\n\\n#plt.hist(dp_pilot_controls[stim_key]['bootstrap_data'])\\nprint(dp_pilot_controls[stim_key]['CIs'])\\nprint(dp_pilot_controls[stim_key]['central_tendency'])\\n\\nstim_key = 'ss_cs'\\ndiffs = [x - y for x in pilot_dprimes[stim_key] for y in controls_dprimes[stim_key]]\\ndp_pilot_controls[stim_key] = bayes_bootstrap(diffs, scipy.median, 1000, len(diffs))\\n\\n#plt.hist(dp_pilot_controls[stim_key]['bootstrap_data'])\\nprint(dp_pilot_controls[stim_key]['CIs'])\\nprint(dp_pilot_controls[stim_key]['central_tendency'])\\n\\nstim_key = 'ss_cp'\\ndiffs = [x - y for x in pilot_dprimes[stim_key] for y in controls_dprimes[stim_key]]\\ndp_pilot_controls[stim_key] = bayes_bootstrap(diffs, scipy.median, 1000, len(diffs))\\n\\n#plt.hist(dp_pilot_controls[stim_key]['bootstrap_data'])\\nprint(dp_pilot_controls[stim_key]['CIs'])\\nprint(dp_pilot_controls[stim_key]['central_tendency'])\\n\\n## Controls vs Patients d'\\ndp_controls_patients = dict()\\n\\nstim_key = 'ss_us'\\ndiffs = [x - y for x in controls_dprimes[stim_key] for y in patients_dprimes[stim_key]]\\ndp_controls_patients[stim_key] = bayes_bootstrap(diffs, scipy.median, 1000, len(diffs))\\n\\n#plt.hist(dp_controls_patients[stim_key]['bootstrap_data'])\\nprint(dp_controls_patients[stim_key]['CIs'])\\nprint(dp_controls_patients[stim_key]['central_tendency'])\\n\\nstim_key = 'ss_cs'\\ndiffs = [x - y for x in controls_dprimes[stim_key] for y in patients_dprimes[stim_key]]\\ndp_controls_patients[stim_key] = bayes_bootstrap(diffs, scipy.median, 1000, len(diffs))\\n\\n#plt.hist(dp_controls_patients[stim_key]['bootstrap_data'])\\nprint(dp_controls_patients[stim_key]['CIs'])\\nprint(dp_controls_patients[stim_key]['central_tendency'])\\n\\nstim_key = 'ss_cp'\\ndiffs = [x - y for x in controls_dprimes[stim_key] \\n         for y in list(filter(None, patients_dprimes[stim_key]))]\\ndp_controls_patients[stim_key] =...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Read mouse data\\ndf_mm = pd.read_table(\\\"GSE59992_counts_table.txt.gz\\\")\\ndf_mm[\\\"loc\\\"] = df_mm[\\\"chrom\\\"] + \\\":\\\" + df_mm[\\\"start\\\"].astype(str) + \\\"-\\\" + df_mm[\\\"end\\\"].astype(str)\\ndf_mm = df_mm.set_index(\\\"loc\\\")\\n\\ndf_mm = df_mm[[\\\"Lsk\\\", \\\"CMP\\\", \\\"GMP\\\", \\\"MEP\\\", \\\"Monocytes\\\", \\\"EryA\\\", \\\"CD4\\\", \\\"CD8\\\", \\\"B-cells\\\", \\\"NK\\\"]]\\ndf_mm.columns = [\\\"MPP\\\", \\\"CMP\\\", \\\"GMP\\\", \\\"MEP\\\", \\\"Monocytes\\\", \\\"Erythroblast\\\", \\\"CD4\\\", \\\"CD8\\\", \\\"Bcell\\\", \\\"Nkcell\\\"]\\n\\ndf_mm = np.log2(df_mm + 1)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nRead mouse ATAC-seq table\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<p style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\n    ננסה לאחזר את התוכן של הקובץ castle.txt:\\n<\\/p>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprincess_location = get_file_content('castle.txt')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"By default all the layers of the VGG16 model are trainable.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprint_layer_trainable()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Astropy can read a variety of formats easily.\\nThe following example uses a quite\\n\",\"targets\":\"# Read the data from the source\\ntable = ascii.read(\\\"ftp:\\/\\/cdsarc.u-strasbg.fr\\/pub\\/cats\\/VII\\/253\\/snrs.dat\\\",\\n                   readme=\\\"ftp:\\/\\/cdsarc.u-strasbg.fr\\/pub\\/cats\\/VII\\/253\\/ReadMe\\\")\\n\\n# See the stats of the table\\ntable.info('stats')\\n\\n# If we want to see the first 10 entries\\ntable[0:10]\\n\\n# the units are also stored, we can extract them too\\ntable['MajDiam'].quantity.to('rad')[0:3]\\n\\n# Adding values of different columns\\n(table['RAh'] + table['RAm'] + table['RAs'])[0:3]\\n\\n\\n# adding values of different columns but being aware of column units\\n(table['RAh'].quantity + table['RAm'].quantity + table['RAs'].quantity)[0:3]\\n\\n# Create a new column in the table\\ntable['RA'] = table['RAh'].quantity + table['RAm'].quantity + table['RAs'].quantity\\n\\n# Show table's new column \\ntable['RA'][0:3]\\n\\n# add a description to the new column\\ntable['RA'].description = table['RAh'].description\\n\\n# Now it does show the values\\ntable['RA'][0:3]\\n\\n\\n# Using numpy to calculate the sin of the RA\\nimport numpy as np\\nnp.sin(table['RA'].quantity)\\n\\n# Let's change the units...\\nimport astropy.units as u\\ntable['RA'].unit = u.hourangle\\n\\n# does the sin now works?\\nnp.sin(table['RA'].quantity)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Comment on your results.\\nAnswer: Interestingly, there's not a huge performance improvement between the two approaches! In my run, using mean imputation corresponded to about a 3 point increase in model performance. Some ideas for why this might be:\\n\\nThis is a small dataset to start out with, so removing ~half its samples doesn't change performance very much\\nThere's not much information contained in the features with missing data\\nThere are other effects underlying poor performance of the model (e.g. regularization parameters) that are having a greater impact\\n\\nPreprocessing categorical variables\\nLoad the TA evaluation dataset. As before, the data and header are split into two files, so you'll have to combine them yourself.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndata_url = 'https:\\/\\/archive.ics.uci.edu\\/ml\\/machine-learning-databases\\/tae\\/tae.data'\\n\\nnames = ['native_speaker', 'instructor', 'course', 'season', 'class_size', 'rating']\\n\\ndf = pandas.read_csv(data_url, header=None, index_col=False, names=names)\\nprint(df)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# no changes are required to this cell\\n# obtain SparkSession\\nsparkSession = SparkSession.builder.getOrCreate()\\n# load data\\nif username:\\n    conversation_df = sparkSession.read.format(\\\"com.cloudant.spark\\\").\\\\\\n                                        option(\\\"cloudant.host\\\", host).\\\\\\n                                        option(\\\"cloudant.username\\\", username).\\\\\\n                                        option(\\\"cloudant.password\\\", password).\\\\\\n                                        load(database)\\nelse:\\n    conversation_df = sparkSession.read.format(\\\"com.cloudant.spark\\\").\\\\\\n                                        option(\\\"cloudant.host\\\", host).\\\\\\n                                        load(database)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLoad documents from the database\\nLoad the documents into an Apache Spark DataFrame.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Ecrivez votre code ci-dessous et éxecutez le. \\n\\n# Une correction est donnée à titre indicatif :\\npoppy.motors\\n\\n\\n\\n\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nComme toute chose en language Python, notre robot poppy est un objet qui contient d'autres objets qui sont ses moteurs.\\nCa y est, si vous arrivez à accéder aux moteurs de Poppy, vous pourrez le faire bouger...\\nVous devez donc accéder aux moteurs de poppy (qui se nomment \\\"motors\\\") et qui se trouve à l'intérieur de Poppy pour cela tapez :\\n\\n<span style=\\\"color:green\\\">nom_du_robot<\\/span><span style=\\\"color:red\\\">.motors<\\/span>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# complete\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nGenerally speaking, the procedure for scikit-learn is uniform across all machine-learning algorithms. Models are accessed via the various modules (ensemble, SVM, neighbors, etc), with user-defined tuning parameters. The features (or data) for the models are stored in a 2D array, X, with rows representing individual sources and columns representing the corresponding feature values.$^\\\\dagger$  In cases where there is a known classification or scalar value (typically supervised methods), this information is stored in a 1D array y. \\n$^\\\\dagger$In a minority of cases, X, represents a similarity or distance matrix where each entry represents the distance to every other source in the data set.\\nUnsupervised models are fit by calling .fit(X) and supervised models are fit by calling .fit(X, y). In both cases, predictions for new observations, Xnew, can be obtained by calling .predict(Xnew). Those are the basics and beyond that, the details are algorithm specific, so ...\\nread the docs!\\nProblem 1a What is the pythonic type of iris?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Pic-ozone\\/Apprent-Python-Ozone.ipynb\\\".\\nThe first task is:\\nRégression logistique ou modèle binomial\\nLa même démarche est déroulée mais en modélisant directement la variable binaire Yb de dépassement ou non du seuil. Il s'agit d'une régression logistique avec toujours une pénalisation Lasso pour opérer une sélection de variables.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom sklearn.linear_model import LogisticRegression\\n\\n# Optimisation du paramètre de pénalisation\\n# grille de valeurs\\nparam=[{\\\"C\\\":[1,1.2,1.5,1.7,2,3,4]}]\\nlogit = GridSearchCV(LogisticRegression(penalty=\\\"l1\\\",solver=\\\"liblinear\\\"), param,cv=5,n_jobs=-1)\\nlogitOpt=logit.fit(Xr_train, Yb_train)  # GridSearchCV est lui même un estimateur\\n# paramètre optimal\\nlogitOpt.best_params_[\\\"C\\\"]\\nprint(\\\"Meilleur score = %f, Meilleur paramètre = %s\\\" % (1.-logitOpt.best_score_,logitOpt.best_params_))\\n\\n# erreur sur l'échantillon test\\n1-logitOpt.score(Xr_test, Yb_test)\",\"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_mixed_source_space_inverse.ipynb\\\".\\nThe first task is:\\nSet up our source space.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# List substructures we are interested in. We select only the\\n# sub structures we want to include in the source space\\nlabels_vol = ['Left-Amygdala',\\n              'Left-Thalamus-Proper',\\n              'Left-Cerebellum-Cortex',\\n              'Brain-Stem',\\n              'Right-Amygdala',\\n              'Right-Thalamus-Proper',\\n              'Right-Cerebellum-Cortex']\\n\\n# Get a surface-based source space. We could set one up like this::\\n#\\n#     >>> src = setup_source_space(subject, fname=None, spacing='oct6',\\n#                                  add_dist=False, subjects_dir=subjects_dir)\\n#\\n# But we already have one saved:\\n\\nsrc = mne.read_source_spaces(op.join(bem_dir, 'sample-oct-6-src.fif'))\\n\\n# Now we create a mixed src space by adding the volume regions specified in the\\n# list labels_vol. First, read the aseg file and the source space bounds\\n# using the inner skull surface (here using 10mm spacing to save time):\\n\\nvol_src = setup_volume_source_space(\\n    subject, mri=fname_aseg, pos=7.0, bem=fname_model,\\n    volume_label=labels_vol, subjects_dir=subjects_dir, verbose=True)\\n\\n# Generate the mixed source space\\nsrc += vol_src\\n\\n# Visualize the source space.\\nsrc.plot(subjects_dir=subjects_dir)\\n\\nn = sum(src[i]['nuse'] for i in range(len(src)))\\nprint('the src space contains %d spaces and %d points' % (len(src), n))\\n\\n# We could write the mixed source space with::\\n#\\n#    >>> write_source_spaces(fname_mixed_src, src, overwrite=True)\\n#\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Get model resource ID\\nmodels = aiplatform.Model.list(filter=\\\"display_name=claritin_\\\" + TIMESTAMP)\\n\\n# Get a reference to the Model Service client\\nclient_options = {\\\"api_endpoint\\\": f\\\"{REGION}-aiplatform.googleapis.com\\\"}\\nmodel_service_client = aiplatform.gapic.ModelServiceClient(\\n    client_options=client_options\\n)\\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\":\"I am working on the file \\\"2.0\\/tutorials\\/RV.ipynb\\\".\\nThe first task is:\\nIf rv_method is set to 'dynamical' then the computed radial velocities are simply the z-velocities of the centers of mass of each component.  In this case, only the dynamical options are relevant.  For more details on these, see the section on the orb dataset.\\nIf rv_method is set to 'flux-weighted' then radial velocities are determined by the z-velocity of each visible surface element of the mesh, weighted by their respective intensities.  Since the stars are placed in their orbits by the dynamic options, the section on the orb dataset is still applicable.  So are the meshing options described in mesh dataset and the options for computing fluxes in lc dataset.\\nrv_grav\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint ps_compute['rv_grav']\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"(2c) RMSE do baseline para os conjuntos de treino, validação e teste \\nVamos calcular o RMSE para nossa baseline. Primeiro crie uma RDD de (rótulo, predição) para cada conjunto, e então chame a função calcRMSE.\\n\",\"targets\":\"# EXERCICIO\\nlabelsAndPredsTrain = parsedTrainData.map(lambda p: (p.label, averageTrainYear))\\nrmseTrainBase = calcRMSE(labelsAndPredsTrain)\\n\\nlabelsAndPredsVal = parsedValData.map(lambda p: (p.label, averageTrainYear))\\nrmseValBase = calcRMSE(labelsAndPredsVal)\\n\\nlabelsAndPredsTest = parsedTestData.map(lambda p: (p.label, averageTrainYear))\\nrmseTestBase = calcRMSE(labelsAndPredsTest)\\n\\nprint ('Baseline Train RMSE = {0:.3f}'.format(rmseTrainBase))\\nprint ('Baseline Validation RMSE = {0:.3f}'.format(rmseValBase))\\nprint ('Baseline Test RMSE = {0:.3f}'.format(rmseTestBase))\\n\\n# TEST Training, validation and test RMSE (2c)\\nassert np.allclose([rmseTrainBase, rmseValBase, rmseTestBase],[21.506125957738682, 20.877445428452468, 21.260493955081916]), 'incorrect RMSE value'\\nprint(\\\"OK\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<img src=\\\"array_multiplication.jpg\\\">\\nQuestion 4.3.2. Suppose the total charge at a restaurant is the original bill plus the tip.  That means we can multiply the original bill by 1.2 to get the total charge.  Compute the total charge for each bill in restaurant_bills.\\n\",\"targets\":\"total_charges = ...\\ntotal_charges\\n\\n_ = tests.grade('q432')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# use default connection (TD_API_KEY is used)\\nengine = td.create_engine('presto:sample_datasets')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\ncreate_engine uses \\\"default\\\" connection if apikey and host are omitted.  In this case, the environment variables \\\"TD_API_KEY\\\" and \\\"TD_API_SERVER\\\" are used to initialize a connection:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Day 1 - Unit 1.3.ipynb\\\".\\nThe first task is:\\nAs with lists, tuples can also be indexed and sliced. However, once assigned, individual components of a tuple cannot be changed. For example, the following code will raise and error\\nCan you write Python code for it?\\n\",\"targets\":\"\\npair[0] = 2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"And here's what the result looks like:\\n\",\"targets\":\"from utils import decorate\\n\\ndef decorate_dice(title=''):\\n    decorate(xlabel='Outcome',\\n             ylabel='PMF',\\n             title=title)\\n\\ntwice = add_dist(die, die)\\ntwice.bar(color='C1', alpha=0.5)\\ndecorate_dice()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"An Ordered Dictionary:\\n\",\"targets\":\"print 'Dictionaries are equal? '\\n\\nd1 = collections.OrderedDict()\\nd1['a'] = 'A'\\nd1['b'] = 'B'\\n\\n\\nd2 = collections.OrderedDict()\\n\\nd2['b'] = 'B'\\nd2['a'] = 'A'\\n\\nprint d1 == d2\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%matlab\\nfigure\\nplot(x,y,'b.');\\nhold on\\nplot(x,ftheta(theta_chap,x),'r');\\n            \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<font color=\\\"red\\\"> Quelles sont les valeurs de theta_chap? A quoi sert l’argument [1 1]? Essayez de reproduire l’estimation avec d’autres valeurs pour cet argument, est-ce que cela affecte le résultat?<\\/font>\\n\\n<font color=\\\"blue\\\">Le paramètre theta_chap vaut [-237.5729 1.7794]. L'argument [1 1] est une valeur initiale de la méthode qui cherche la valeur theta_chap. En répétant l'expérience pour plusieurs valeurs ([2 2], [30 30], [-30 -30]) on voit que la résultat theta_chap ne semble pas dépendre ici de ce paramètre. <\\/font>\\n<ol start=\\\"5\\\">\\n  <h4><li>Maintenant représenter le résultat de la régression. <\\/li><\\/h4>\\n<\\/ol>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# TODO: Calculate number of students\\nn_students = student_data.shape[0]\\n\\n# TODO: Calculate number of features\\nn_features = student_data.shape[1] -1\\n\\n# TODO: Calculate passing students\\nn_passed = np.sum(student_data.passed == 'yes')\\n\\n# TODO: Calculate failing students\\nn_failed = np.sum(student_data.passed =='no')\\n\\n# TODO: Calculate graduation rate\\ngrad_rate = 100 * np.mean(student_data.passed == 'yes')\\n\\n# Print the results\\nprint \\\"Total number of students: {}\\\".format(n_students)\\nprint \\\"Number of features: {}\\\".format(n_features)\\nprint \\\"Number of students who passed: {}\\\".format(n_passed)\\nprint \\\"Number of students who failed: {}\\\".format(n_failed)\\nprint \\\"Graduation rate of the class: {:.2f}%\\\".format(grad_rate)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nImplementation: Data Exploration\\nLet's begin by investigating the dataset to determine how many students we have information on, and learn about the graduation rate among these students. In the code cell below, you will need to compute the following:\\n- The total number of students, n_students.\\n- The total number of features for each student, n_features.\\n- The number of those students who passed, n_passed.\\n- The number of those students who failed, n_failed.\\n- The graduation rate of the class, grad_rate, in percent (%).\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Change True to 1, False to 0\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndiabetes_map = {True : 1, False : 0}\\n\\ndf['diabetes'] = df['diabetes'].map(diabetes_map)\\n\\ndf.head(5)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<a id='save'><\\/a>\\nHere we cover two main ways to save data files for use again later, one that is Python-specific, and the other a simple text format.\\n\\nnp.save('file_path', array_name) - Creates a .npy file (Python readable only!)\\nnp.savetxt('file_path', array_name) - Creates a plain text (or .txt) file (more generally readable)\\n\\nThe basic syntax is pretty much the same for each. What differs is the type of file that the functions create. Below is an example of how each function can be called to store the same data.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nnp.save('.\\/lecture2_data\\/dataFix.npy',dataFix)\\nnp.savetxt('.\\/lecture2_data\\/dataFix.txt',dataFix)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# include 1-grams and 2-grams\\nvect = CountVectorizer(ngram_range=(1, 2), min_df=5)\\nX_train_dtm = vect.fit_transform(X_train)\\nX_train_dtm.shape\\n\\n# last 50 features\\nprint(vect.get_feature_names()[-50:])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nngram_range: tuple (min_n, max_n)\\nThe lower and upper boundary of the range of n-values for different n-grams to be extracted. All values of n such that min_n <= n <= max_n will be used.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2.3 Prediction (10 points)\\nThe predictive distribution of Bayesian linear regression is:\\n$$ p(t \\\\;|\\\\; \\\\bx, \\\\bt, \\\\alpha, \\\\beta) = \\\\mathcal{N}(t \\\\;|\\\\; \\\\bm_N^T \\\\phi(\\\\bx), \\\\sigma_N^2(\\\\bx))$$\\n$$ \\\\sigma_N^2 = \\\\frac{1}{\\\\beta} + \\\\phi(\\\\bx)^T \\\\bS_N \\\\phi(\\\\bx) $$\\nwhere $\\\\phi(\\\\bx)$ are the computed features for a new datapoint $\\\\bx$, and $t$ is the predicted variable for datapoint $\\\\bx$. \\nWrite a function that predict_polynomial_bayes(x, m, S, beta) that returns the predictive mean, variance and design matrix $\\\\bPhi$ given a new datapoint x, posterior mean m, posterior variance S and a choice of model variance beta.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef predict_polynomial_bayes(x, m, S, beta):\\n    \\\"\\\"\\\"\\n    Predict the target values for input x\\n    and return the predictions, the posterior variance and Phi.\\n    \\\"\\\"\\\"\\n    Phi = designmatrix(x, len(m)-1)\\n    sigma = [(1 \\/ beta + np.asscalar(Phi[i] * S * Phi[i].T))\\n             for i in range(len(x))]\\n    mean = [np.asscalar(m*Phi[i].T) for i in range(len(x))]\\n\\n    return np.array(mean), np.array(sigma), Phi\\n\\n\\n### Test your function\\nnp.random.seed(5)\\nN = 10\\nx = np.linspace(-1, 1, N)\\nm = np.empty(3)\\nS = np.empty((3, 3))\\nbeta = 25\\nmean, sigma, Phi = predict_polynomial_bayes(x, m, S, beta)\\n\\nassert mean.shape == (N,), \\\"the shape of mean is incorrect\\\"\\nassert sigma.shape == (N,), \\\"the shape of sigma is incorrect\\\"\\nassert Phi.shape == (N, m.shape[0]), \\\"the shape of Phi is incorrect\\\"\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Accuracy\\nDecreasing tolerance below improves the shape of responses, at the expense of increased number of timesteps.\\n\",\"targets\":\"reltol = 1e-5  # decrease to increase quality and runtime\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"04_Visualisation\\/4_Visualisation.ipynb\\\".\\nThe first task is:\\nJ'ai utilisé le format d'image png, utile pour les images de type graphique, avec des changements de couleurs drastiques. Pour les photos, vous préférerez le format jpg. Des éditeurs demandront peut-être des formats vectoriels comme pdf ou eps. Si vous désirez éditer vos graphiques (bouger des étiquettes ou des légendes, ajouter des éléments graphiques), vous pouvez exporter voter graphique en format svg, puis l'éditer dans le logiciel libre Inkscape. Quoi qu'il en soit, voici les format d'exportation disponibles.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfig.canvas.get_supported_filetypes()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"8.3.1 Matches and Perfect Matches\\nmatching: a matching is a subset of the edges such that no node is an end of two or more edges.\\nperfect matching: a matching is said to be perfect if every node appears in the matching.\\nmaximal matching: a matching that is as large as any other matching for the graph in question is said to be maximal.\\n\",\"targets\":\"plt.figure(figsize=(8,8))\\nplt.imshow(plt.imread('.\\/res\\/fig8_2.png'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Bal\\nБалкона может не быть, балкон может быть, а еще балконов может быть больше одного. Информации о балконе может не быть.\\nТак что будем готовы к значениям > 1. Прочерк будет говорить о том, что информации нет, слово \\\"нет\\\" - о том, что есть информация о том, что нет балкона.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef getBal(flat_page):\\n    table = flat_page.find('table', attrs = {'class':'object_descr_props'})\\n    table = html_stripper(table)\\n    \\n    space_block = re.split('Общая площадь', table)[1]\\n    optional_block = re.split('Жилая площадь', space_block)[1]\\n    \\n    balcony = np.nan\\n    if 'Балкон' in optional_block:\\n        balcony_block = re.split('Балкон', optional_block)[1]\\n        if re.split('\\\\n', balcony_block)[1] != 'нет':\\n            if re.split('\\\\n', balcony_block)[1] != '–':\\n                balcony = int(re.split('\\\\n', balcony_block)[1][0])\\n        else:\\n            balcony = 0\\n            \\n    return balcony\\n\\ndef getAllBal(l, r):\\n    \\n    bal = []\\n    \\n    for i in range(l, r):\\n        flat_url = 'http:\\/\\/www.cian.ru\\/sale\\/flat\\/' + str(links[i]) + '\\/'\\n        flat_page = requests.get(flat_url)\\n        flat_page = flat_page.content\\n        flat_page = BeautifulSoup(flat_page, 'lxml')\\n        bal.append(getBal(flat_page))\\n        \\n    return bal\\n\\nbal = getAllBal(0, len(links))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Calculate losses\\nlabels_real = tf.ones_like(d_logits_real) * (1 - smooth)\\nd_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real, labels=labels_real))\\n\\nlabels_fake = tf.zeros_like(d_logits_fake)\\nd_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake, labels=labels_fake))\\n\\nd_loss = d_loss_real + d_loss_fake\\n\\ng_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake, labels=tf.ones_like(d_logits_fake)))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nDiscriminator and Generator Losses\\nNow we need to calculate the losses, which is a little tricky. For the discriminator, the total loss is the sum of the losses for real and fake images, d_loss = d_loss_real + d_loss_fake. The losses will by sigmoid cross-entropies, which we can get with tf.nn.sigmoid_cross_entropy_with_logits. We'll also wrap that in tf.reduce_mean to get the mean for all the images in the batch. So the losses will look something like \\npython\\ntf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=labels))\\nFor the real image logits, we'll use d_logits_real which we got from the discriminator in the cell above. For the labels, we want them to be all ones, since these are all real images. To help the discriminator generalize better, the labels are reduced a bit from 1.0 to 0.9, for example,  using the parameter smooth. This is known as label smoothing, typically used with classifiers to improve performance. In TensorFlow, it looks something like labels = tf.ones_like(tensor) * (1 - smooth)\\nThe discriminator loss for the fake data is similar. The logits are d_logits_fake, which we got from passing the generator output to the discriminator. These fake logits are used with labels of all zeros. Remember that we want the discriminator to output 1 for real images and 0 for fake images, so we need to set up the losses to reflect that.\\nFinally, the generator losses are using d_logits_fake, the fake image logits. But, now the labels are all ones. The generator is trying to fool the discriminator, so it wants to discriminator to output ones for fake images.\\n\\nExercise: Calculate the losses for the discriminator and the generator. There are two discriminator losses, one for real images and one for fake images. For the real image loss, use the real logits and (smoothed) labels of ones. For the fake image loss, use the fake logits with labels of all zeros. The total discriminator loss is the sum of those two losses. Finally, the generator loss again uses the fake logits from the...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Considerations\\nmodel_card.considerations contains qualifying information about your model - what are the appropriate use cases, what are limitations that users should keep in mind, what are the ethical considerations of application, etc.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nmodel_card.considerations.use_cases = [\\n    mctlib.UseCase(description='This model classifies images of cats and dogs.')\\n]\\nmodel_card.considerations.limitations = [\\n    mctlib.Limitation(description='This model is not able to classify images of other classes.')\\n]\\nmodel_card.considerations.ethical_considerations = [mctlib.Risk(\\n    name=\\n        'While distinguishing between cats and dogs is generally agreed to be '\\n        'a benign application of machine learning, harmful results can occur '\\n        'when the model attempts to classify images that don’t contain cats or '\\n        'dogs.',\\n    mitigation_strategy=\\n        'Avoid application on non-dog and non-cat images.'\\n)]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# FIXME\\nn = 20\\n\\nx = np.random.uniform(-1,1,(n,1))\\ny = 4*x[:,0] + np.random.normal(0,0.3, (n,))\\n\\nplt.scatter(x,y)\\n\\n# simple univariate regression \\n\\nfor n in range(20):\\n    ridge = sklearn.linear_model.Ridge(alpha=1*np.exp(-n), fit_intercept=True)\\n    ridge.fit(x,y)\\n    # predict output\\n    xs = np.linspace(-1,1,100)[:, None]\\n    ys = ridge.predict(xs)\\n    plt.plot(xs,ys,c=[n\\/20.0, n\\/20.0, n\\/20.0, 1])\\n    plt.ylim(-5,5)\\n\\n\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nOverfitting and regularisation\\nOverfitting\\nWe saw examples of overfitting in the previous lecture. Preventing overfitting is one of the major challenges of machine learning. It is easy to build models that can approximate any function; but approximating in a way that generalises to unseen data is much harder.\\nEnforcing structure to minimise overfitting is called regularisation. Techniques such as bagging or bootstrap methods that we saw in the previous lecture are examples of randomised approaches to regularisation.  By forcing learning algorithms to learn from impoverished datasets and then averaging the results, we can prevent the learning from conforming into the irrelvant \\\"nooks and crannies\\\" of the functions to be learned.\\nPenalisation\\nAn alternative approach is to explicitly penalise functions for getting too complicated. This is called penalisation and is widely used in statistical modelling. An explicit penalty function is defined which applies a constraint to the optimisation of parameters to force the function being learned to stay \\\"smooth\\\".\\nDeveloping a penalty function is tricky, as it is not always clear how enforcing constraints of the parameters of a learning algorithm affects the generalisation properties of the result. However, there are many well-developed techniques for which good penalty function are known. \\nThese functions often try to make the parameters small or to make as many of them as possible zero (maximising sparseness).\\nLasso \\/ ridge regression\\nOne common approach is to apply penalties when fitting a linear model (i.e. $y=w^Tx$) that constrain the values of linear fit to be small. The specific norm used to measure the size of the coefficients gives rise to various regularisation approaches.\\nAn approach which forces the coefficients to be small in the $L_2$ norm (i.e. the Euclidean distance of the coefficient vector to the origin) is called ridge regression; using the $L_1$ norm (the sum of coefficient values) is called lasso regression.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"All these traveling weather systems tend to move warm, moist air poleward and cold, dry air equatorward. There is thus a net poleward energy transport.\\nA model like this needs to simulate the weather in order to model the heat transport.  \\nA simpler statistical approach\\nLet’s emphasize: the most important role for heat transport by winds and ocean currents is to more energy from where it’s WARM to where it’s COLD, thereby reducing the temperature gradient (equator to pole) from what it would be if the planet were in radiative-convective equilibrium everywhere with no north-south motion.\\nThis is the basis for the parameterization of heat transport often used in simple climate models.\\nDiscuss analogy with molecular heat conduction: metal rod with one end in the fire.\\nDefine carefully temperature gradient dTs \\/ dy\\nMeasures how quickly the temperature  decreases as we move northward\\n(negative in NH, positive in SH)\\nIn any conduction or diffusion process, the flux (transport) of a quantity is always DOWN-gradient  (from WARM to COLD).\\nSo our parameterization will look like\\n$$ \\\\mathcal{H} = -K ~ dT \\/ dy $$\\nWhere $K$ is some positive number “diffusivity of the climate system”.\\n\\n<a id='section2'><\\/a>\\n2. The temperature diffusion parameterization\\n\\nLast time we wrote down an energy budget for a thin zonal band centered at latitude $\\\\phi$:\\n$$ \\\\frac{\\\\partial E(\\\\phi)}{\\\\partial t} = \\\\text{ASR}(\\\\phi) - \\\\text{OLR}(\\\\phi) - \\\\frac{1}{2 \\\\pi a^2  \\\\cos⁡\\\\phi } \\\\frac{\\\\partial \\\\mathcal{H}}{\\\\partial \\\\phi} $$\\nwhere we have written every term as an explicit function of latitude to remind ourselves that this is a local budget, unlike the zero-dimensional global budget we considered at the start of the course.\\nLet’s now formally introduce a parameterization that approximates the heat transport as a down-gradient diffusion process:\\n$$ \\\\mathcal{H}(\\\\phi) \\\\approx -2 \\\\pi a^2  \\\\cos⁡\\\\phi ~ D ~ \\\\frac{\\\\partial T_s}{\\\\partial \\\\phi} $$\\nWith $D$ a parameter for the diffusivity or thermal conductivity of the climate system, a number in W m$^{-2}$...\\\"\\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 climlab\\nfrom climlab import constants as const\\n\\n#  First define an initial temperature field\\n#   that is warm at the equator and cold at the poles\\n#   and varies smoothly with latitude in between\\n\\nfrom climlab.utils import legendre\\nsfc = climlab.domain.zonal_mean_surface(num_lat=90, water_depth=10.)\\nlat = sfc.lat.points\\ninitial = 12. - 40. * legendre.P2(np.sin(np.deg2rad(lat)))\\n\\nfig, ax = plt.subplots()\\nax.plot(lat, initial)\\nax.set_xlabel('Latitude')\\nax.set_ylabel('Temperature (deg C)')\\n\\n##  Set up the climlab diffusion process\\n\\n# make a copy of initial so that it remains unmodified\\nTs = climlab.Field(np.array(initial), domain=sfc)\\n# thermal diffusivity in W\\/m**2\\/degC\\nD = 0.55\\n# create the climlab diffusion process\\n#  setting the diffusivity and a timestep of ONE MONTH\\nd = climlab.dynamics.MeridionalHeatDiffusion(name='Diffusion', \\n            state=Ts, D=D, timestep=const.seconds_per_month)\\nprint( d)\\n\\n#  We are going to step forward one month at a time\\n#  and store the temperature each time\\nniter = 5\\ntemp = np.zeros((Ts.size, niter+1))\\ntemp[:, 0] = np.squeeze(Ts)\\nfor n in range(niter):\\n    d.step_forward()\\n    temp[:, n+1] = np.squeeze(Ts)\\n\\n#  Now plot the temperatures\\nfig,ax = plt.subplots()\\nax.plot(lat, temp)\\nax.set_xlabel('Latitude')\\nax.set_ylabel('Temperature (deg C)')\\nax.legend(range(niter+1))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"By default our triple has an equal mass inner binary, so the octupole order term is zero!  We can see this explicitly by looking at the $C_3$ coefficient:\\n\",\"targets\":\"triple.C3\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"And then a second model with extinction.\\n\",\"targets\":\"b.set_value('Av',2.0)\\nb.run_compute(model='ext',overwrite=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"6. Which variables are binary?\\n\",\"targets\":\"result=getDfSummary(ads)\\nresult.loc[(result.Number_Distinct==2)]\\n\\n#We can use Number_Distinct as an indicator of binary variables since the value of the below four variables can either be 0 or 1.\\n#Number_Distinct of the below four variables is 2 and max and min is 1 and 0 respectively.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"18.\\nLet us inspect the weights (coefficients) of the simple_model. First, build a table to store (word, coefficient) pairs. If you are using SFrame with scikit-learn, you can combine words with coefficients by running\\n\",\"targets\":\"simple_model_coef_table = pd.DataFrame({'word':significant_words,\\n                                         'coefficient':simple_model.coef_.flatten()})\\n#simple_model_coef_table\\nsimple_model_coef_table.sort_values(['coefficient'], ascending=False)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# We know that MNIST images are 28 pixels in each dimension.\\nimg_size = 28\\n\\n# Images are stored in one-dimensional arrays of this length.\\nimg_size_flat = img_size * img_size\\n\\n# Tuple with height and width of images used to reshape arrays.\\n# This is used for plotting the images.\\nimg_shape = (img_size, img_size)\\n\\n# Tuple with height, width and depth used to reshape arrays.\\n# This is used for reshaping in Keras.\\nimg_shape_full = (img_size, img_size, 1)\\n\\n# Number of colour channels for the images: 1 channel for gray-scale.\\nnum_channels = 1\\n\\n# Number of classes, one class for each of 10 digits.\\nnum_classes = 10\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nData Dimensions\\nThe data dimensions are used in several places in the source-code below. They are defined once so we can use these variables instead of numbers throughout the source-code below.\",\"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)\\n\",\"targets\":\"lstm_layers = 1\\nkeep_prob = 1\\n\\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 = tf.contrib.rnn.BasicLSTMCell(rnn_size)\\n    drop = tf.contrib.rnn.DropoutWrapper(lstm, output_keep_prob=keep_prob)\\n    cell = tf.contrib.rnn.MultiRNNCell([drop] * lstm_layers)\\n    cell_state = cell.zero_state(batch_size, tf.float32)\\n    cell_state = tf.identity(cell_state, name = 'initial_state')\\n    return cell, cell_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\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Python\\/5 Linear Regression\\/Simple-Linear-Regression.ipynb\\\".\\nThe first task is:\\nNext, we compute the residual sum of squares RSS as follows:\\n$$ \\\\mathtt{RSS} := \\\\sum\\\\limits_{i=1}^m \\\\bigl(\\\\vartheta_1 \\\\cdot x_i + \\\\vartheta_0 - y_i\\\\bigr)^2 $$\\nCan you write Python code for it?\\n\",\"targets\":\"\\nRSS = np.sum((ϑ1 * X + ϑ0 - Y) ** 2)\\nRSS\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create the model\\nIt's time to create your neural network:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nembedding_dim = 16\\n\\n# Create your neural network\\nmodel = tf.keras.Sequential([\\n  layers.Embedding(max_features + 1, embedding_dim),\\n  layers.Dropout(0.2),\\n  layers.GlobalAveragePooling1D(),\\n  layers.Dropout(0.2),\\n  layers.Dense(1)])\\n\\nmodel.summary()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Creating Dictionary through assignment.\\nWe can create a dictionary by assignment also. As with lists, dictionary are also not of fixed size. You can add any number of values to a dictionary.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nd = {}\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As an example, let's use the celltypes column to make a list of each celltype color first. Notice that we can use cell_metadata.celltype or cell_metadata['celltype'] to get the column we want.\\nWe can only use the 'dot' notation because our column name has no unfriendly characters like spaces, dashes, or dots -- characters that mean something special in Python.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncelltypes = cell_metadata.celltype.unique()  # Could also use cell_metadata['celltype'].unique()\\ncelltypes\\n\\ncelltype_to_color = dict(zip(celltypes, sns.color_palette('Accent', n_colors=len(celltypes))))\\ncelltype_to_color\",\"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:\\nNow we can use our cv to fit_transform our training list of novels (strings!):\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndtm = cv.fit_transform(train)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Initialize the structured data classifier.\\nclf = ak.StructuredDataClassifier(\\n    overwrite=True, max_trials=3\\n)  # It tries 3 different models.\\n# Feed the structured data classifier with training data.\\nclf.fit(\\n    # The path to the train.csv file.\\n    train_file_path,\\n    # The name of the label column.\\n    \\\"survived\\\",\\n    epochs=10,\\n)\\n# Predict with the best model.\\npredicted_y = clf.predict(test_file_path)\\n# Evaluate the best model with testing data.\\nprint(clf.evaluate(test_file_path, \\\"survived\\\"))\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe second step is to run the\\nStructuredDataClassifier.\\nAs a quick demo, we set epochs to 10.\\nYou can also leave the epochs unspecified for an adaptive number of epochs.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Again, also for writing we can use a with statement, which is very handy.\\nBut let's have a look at what happens here, so we understand a bit better why \\\"write mode\\\" must be used carefully!\\n\",\"targets\":\"with open(\\\"test.txt\\\", \\\"w\\\") as out:\\n    out.write(\\\"Oooops! new content\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"After two vanilla cookies, the high-numbered bowls have the highest posterior probabilities because they contain the most vanilla cookies; the low-numbered bowls have the lowest probabilities.\\nBut suppose we draw again and get a chocolate cookie.\\nHere's the update:\\n\",\"targets\":\"likelihood_chocolate = 1 - hypos\\/100\\n\\nposterior3 = posterior2 * likelihood_chocolate\\nposterior3.normalize()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2.2 Loading and Transforming the Data\\nThe data is loaded and transformed as follows:\\n\",\"targets\":\"training = np.loadtxt(\\\"data\\/in.dta\\\")\\nX_train = add_ones_column(training[:,:-1])\\ny_train = training[:,-1]\\nX_train = add_nonlinear_features(X_train,7)\\nn_train = y_train.shape[0]\\n\\ntesting  = np.loadtxt(\\\"data\\/out.dta\\\")\\nX_test  = add_ones_column(testing[:,:-1])\\ny_test  = testing[:,-1]\\nX_test  = add_nonlinear_features(X_test,7)\\nn_test = y_test.shape[0]\\n\\nn_features = X_train.shape[1]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Access to the Image Mosaics\\nAdditional to the data, we also provide the image mosaics used to extract the information in the MVM-VAC. To access these mosaics use the instruction: morp.show_mosaic('survey')\\nVersion_1.0.1 (DR16). For this version there are two sets of mosaics: \\ni) the SDSS mosaic, containing a gray logarithmic-scaled r-band image, a filter-enhanced r-band image and the corresponding gri colour composite image, from the SDSS images. 'survey'='sdss'\\nii) the DESI mosaic, containing a filter-enhanced r-band image and the corresponding gri colour composite image, from the DESI images. 'survey'='desi'\\nVersion_2.0.1 (DR17).\\nFor this version, we have combined the relevant information from SDSS and DESI surveys in one mosaic. This mosacis contains the gri colour composite image from SDSS; the grz colour composite image, the residual image after subtraction of a best surface brightness model and the filter-enhanced r-band image from the DESI Legacy Surveys. 'survey'='mos'\\n\",\"targets\":\"morp.show_mosaic('sdss')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Solution\\n\\n# We'll need an object to keep track of the number of cookies in each bowl. \\n# I use a Hist object, defined in thinkbayes2:\\n\\nbowl1 = Hist(dict(vanilla=30, chocolate=10))\\nbowl2 = Hist(dict(vanilla=20, chocolate=20))\\n\\nbowl1.Print()\\n\\n# Solution\\n\\n# Now I'll make a Pmf that contains the two bowls, giving them equal probability.\\n\\npmf = Pmf([bowl1, bowl2])\\npmf.Print()\\n\\n# Solution\\n\\n# Here's a likelihood function that takes `hypo`, which is one of \\n# the Hist objects that represents a bowl, and `data`, which is either \\n# 'vanilla' or 'chocolate'.\\n\\n# `likelihood` computes the likelihood of the data under the hypothesis, \\n# and as a side effect, it removes one of the cookies from `hypo`\\n\\ndef likelihood(hypo, data):\\n    like = hypo[data] \\/ hypo.Total()\\n    if like:\\n        hypo[data] -= 1\\n    return like\\n\\n# Solution\\n\\n# Now for the update.  We have to loop through the hypotheses and \\n# compute the likelihood of the data under each hypothesis.\\n\\ndef update(pmf, data):\\n    for hypo in pmf:\\n        pmf[hypo] *= likelihood(hypo, data)\\n    return pmf.Normalize()\\n\\n# Solution\\n\\n# Here's the first update.  The posterior probabilities are the \\n# same as what we got before, but notice that the number of cookies \\n# in each Hist has been updated.\\n\\nupdate(pmf, 'vanilla')\\npmf.Print()\\n\\n# Solution\\n\\n# So when we update again with a chocolate cookies, we get different \\n# likelihoods, and different posteriors.\\n\\nupdate(pmf, 'chocolate')\\npmf.Print()\\n\\n# Solution\\n\\n# If we get 10 more chocolate cookies, that eliminates Bowl 1 completely\\n\\nfor i in range(10):\\n    update(pmf, 'chocolate')\\n    print(pmf[bowl1])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise In Section 2.3 I said that the solution to the cookie problem generalizes to the case where we draw multiple cookies with replacement.\\nBut in the more likely scenario where we eat the cookies we draw, the likelihood of each draw depends on the previous draws.\\nModify the solution in this chapter to handle selection without replacement. Hint: add instance variables to Cookie to represent the hypothetical state of the bowls, and modify Likelihood accordingly. You might want to define a Bowl object.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"5-sympy.ipynb\\\".\\nThe first task is:\\nLa función subs también puede ser usada para substituir símbolos y expresiones:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ny.subs(x, a+sym.pi)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Train the model on our training data while validating on our validation set\\nhistory_1 = model_1.fit(x_train, y_train, epochs=1000, batch_size=16,\\n                    validation_data=(x_validate, y_validate))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTrain the model\\nOnce we've defined the model, we can use our data to train it. Training involves passing an x value into the neural network, checking how far the network's output deviates from the expected y value, and adjusting the neurons' weights and biases so that the output is more likely to be correct the next time.\\nTraining runs this process on the full dataset multiple times, and each full run-through is known as an epoch. The number of epochs to run during training is a parameter we can set.\\nDuring each epoch, data is run through the network in multiple batches. Each batch, several pieces of data are passed into the network, producing output values. These outputs' correctness is measured in aggregate and the network's weights and biases are adjusted accordingly, once per batch. The batch size is also a parameter we can set.\\nThe code in the following cell uses the x and y values from our training data to train the model. It runs for 1000 epochs, with 16 pieces of data in each batch. We also pass in some data to use for validation. As you will see when you run the cell, training can take a while to complete:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"1.d)  Grafica un histograma de numeros aleatorios con $n=10,50,100,1k,10k$\\nPara graficar histogramas usa plt.hist().\\n\",\"targets\":\"import matplotlib.pyplot as plt\\nimport numpy as np\\n%matplotlib inline\\n\\na = np.random.randint(1,10,10)\\nplt.hist(a)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%bash\\nOUTDIR=babyweight_trained\\nrm -rf ${OUTDIR}\\nexport PYTHONPATH=${PYTHONPATH}:${PWD}\\/babyweight\\npython3 -m trainer.task \\\\\\n    --train_data_path=gs:\\/\\/${BUCKET}\\/babyweight\\/data\\/train*.csv \\\\\\n    --eval_data_path=gs:\\/\\/${BUCKET}\\/babyweight\\/data\\/eval*.csv \\\\\\n    --output_dir=${OUTDIR} \\\\\\n    --batch_size=# TODO: Add batch size\\n    --num_epochs=# TODO: Add the number of epochs to train for\\n    --train_examples=# TODO: Add the number of examples to train each epoch for\\n    --eval_steps=# TODO: Add the number of evaluation batches to run\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTrain locally\\nAfter moving the code to a package, make sure it works as a standalone. Note, we incorporated the --train_examples flag so that we don't try to train on the entire dataset while we are developing our pipeline. Once we are sure that everything is working on a subset, we can change it so that we can train on all the data. Even for this subset, this takes about 3 minutes in which you won't see any output ...\\nLab Task #3: Run trainer module package locally.\\nFill in the missing code in the TODOs below so that we can run a very small training job over a single file with a small batch size, 1 epoch, 1 train example, and 1 eval step.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"01_openlibs\\/tensorflow\\/03_segmentfault\\/00_introduction.ipynb\\\".\\nThe first task is:\\n下面我们来剖析一下关键代码。TensorFlow的代码往往由两个部分组成：\\n\\nA construction phase, that assembles a graph \\nAn execution phase that uses a session to execute ops in the graph.\\n\\nSession是一个类，作用是把graph ops部署到Devices（CPUs\\/GPUs），并提供具体执行这些op的方法。\\n为什么要这么设计呢？考虑到Python运行性能较低，我们在执行numerical computing的时候，都会尽量使用非python语言编写的代码，比如使用NumPy这种预编译好的C代码来做矩阵运算。\\n在Python内部计算环境和外部计算环境（如NumPy）切换需要花费的时间称为overhead cost。对于一个简单运算，比如矩阵运算，从Python环境切换到Numpy，Numpy运算得到结果，再从Numpy切回Python，这个成本，比纯粹在Python内部做同类运算的成本要低很多。但是，一个复杂数值运算由多个基本运算组合而成，如果每个基本运算来一次这种环境切换，overhead cost就不可忽视了。为了减少来回的环境切换，TensorFlow的做法是，先在Python内定义好整个Graph，然后在Python外运行整个完整的Graph。因此TensorFlow的代码结构也就对应为两个阶段了。\\nBuild Graph\\nCan you write Python code for it?\\n\",\"targets\":\"\\nW = tf.Variable(tf.random_uniform([1], -1.0, 1.0))\\nb = tf.Variable(tf.zeros([1]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<font color=blue>\\nCost\\n<\\/font>\\n<font color=blue>\\nThe cost of migration between an origin and destination is the weighted average of the distance, migration history, shared language and political barriers between the two countries. \\n\\\\begin{equation}\\nC = { \\\\alpha_1 \\\\frac{D_{O\\\\leftrightarrow D}} {D_{Max}} + \\\\alpha_2 MH_{O\\\\rightarrow D}  + \\\\alpha_3 L_{O\\\\leftrightarrow D} + \\\\alpha_4 PB}\\n\\\\end{equation}\\n<\\/font>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Cost\\nalpha1=.35\\nalpha2=.35\\nalpha3=.15\\nalpha4=.15\\nc = (alpha1*world.matrices[\\\"distance\\\"] +\\n     alpha2*world.matrices[\\\"Migration History\\\"] +\\n     alpha3*world.matrices[\\\"language\\\"] +\\n     alpha4*world.matrices[\\\"Political Barriers\\\"])\\nworld.add_matrix(\\\"cost\\\", c * world.data['beta'])\\n\\nmap_plot(world.matrices[\\\"cost\\\"][\\\"SYR\\\"], title=\\\"Costs (SYR)\\\")\\n\\nmap_plot(world.matrices[\\\"cost\\\"][\\\"FRA\\\"], title=\\\"Costs (FRA)\\\")\\n\\nworld.update_neighborhoods((1 - world.data[\\\"Unemployment\\\"]) * world.data[\\\"rts\\\"], \\\"wages\\\")\\n\\nmap_plot(world.data[\\\"wages\\\"], title=\\\"Wages\\\")\\n\\n#beta = world.data.rts.mean()\\n#beta = RTS_list.median()\\n\\nworld.add_matrix(\\\"migration\\\", (pd.DataFrame(\\n    np.array(\\n        [[x] * len(world.data) for x in world.data[\\\"wages\\\"].values]\\n    ) - np.array(\\n        [list(world.data[\\\"wages\\\"].values)] * len(world.data)\\n    ),\\n    world.data.index,\\n    world.data.index\\n    )  - world.matrices[\\\"cost\\\"]).clip(lower=0))\\nworld.matrices[\\\"migration\\\"] = world.matrices[\\\"migration\\\"] \\/ (world.matrices[\\\"migration\\\"].sum() + 1)\\nworld.matrices[\\\"migration\\\"] = world.matrices[\\\"migration\\\"] \\/ world.matrices[\\\"migration\\\"].sum(axis=1).max()\\n\\n# TODO: Why does this require being transposed?\\nworld.matrices[\\\"migration\\\"] = (0.15 * world.matrices[\\\"migration\\\"].transpose() * world.data[\\\"Population\\\"]).transpose()\\n\\nworld.matrices[\\\"migration\\\"]\\n\\nmap_plot(\\n   world.matrices[\\\"migration\\\"].sum(axis=1)+1,\\n   title=\\\"Immigration Estimations (x={})\\\".format(skill.value),\\n   normc=matplotlib.colors.LogNorm\\n)\\n\\nmap_plot(\\n   world.matrices[\\\"migration\\\"].sum(),\\n   title=\\\"Estimated Number of Emigrants (x={})\\\".format(skill.value),\\n   normc=matplotlib.colors.Normalize\\n)\\n\\nmap_plot(\\n   world.matrices[\\\"migration\\\"].sum(axis=1) - world.matrices[\\\"migration\\\"].sum(),\\n   title=\\\"Net Migration (x={})\\\".format(skill.value),\\n   normc=gos.visualization.MidPointNorm\\n)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# iterate through all train and validation batches\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise: Use the for loop to iterate through all train and validation batches.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2.2 Leave-one-out Cross-Validation Example\\n\",\"targets\":\"from sympy import Matrix, Rational, Eq, sqrt\\nvar('x1 x2 x3 rho')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2. Grid Search for Optimal Parameter Values\\n\",\"targets\":\"df = pd.DataFrame(columns=['beta', 'sigma_z', 'score'])\\noutDfRow = -1\\nsaveResults = False\\nnoiseLevels = np.linspace(0, 100, 21)\\nnoiseLevels = [5]\\nsampleRates = [1, 5, 10, 20, 30]\\nsampleRates = [5]\\nbetas = np.linspace(1,10,19)\\nsigmaZs = np.linspace(1,10,19)\\n\\nfor i, rteCoords in enumerate(routeList):\\n    print(\\\"Processig route {0} of {1}\\\".format(i, len(routeList)))\\n    shape, routeUrl = val.get_route_shape(rteCoords)\\n    \\n    for beta in betas:\\n        \\n        for sigmaZ in sigmaZs:\\n            print(\\\"Computing score for sigma_z: {0}, beta: {1}\\\".format(\\n                        sigmaZ, beta))\\n            edges, shapeCoords, traceAttrUrl = val.get_trace_attrs(\\n                shape, beta=beta, sigmaZ=sigmaZ)\\n            edges = val.get_coords_per_second(shapeCoords, edges, '2768')\\n\\n            for noise in noiseLevels:\\n                noise = round(noise,3)\\n\\n                for sampleRate in sampleRates:\\n                    outDfRow += 1\\n                    df.loc[outDfRow, ['beta','sigma_z']] = [beta, sigmaZ]\\n                    dfEdges = val.format_edge_df(edges)\\n                    dfEdges, jsonDict, geojson = val.synthesize_gps(\\n                        dfEdges, shapeCoords, '2768', noise=noise, sampleRate=sampleRate, \\n                        beta=beta, sigmaZ=sigmaZ)\\n                    segments, reportUrl = val.get_reporter_segments(jsonDict)\\n                    matches, score = val.get_matches(segments, dfEdges)\\n                    df.loc[outDfRow, 'score'] = score\\n\\n                    if saveResults:\\n                        matches.to_csv(\\n                            '..\\/data\\/matches_{0}_to_{1}_w_{2}_m_noise_at_{3}_Hz.csv'.format(\\n                                stName, endName, str(noise), str(Hz)), index=False)\\n                        with open('..\\/data\\/trace_{0}_to_{1}_w_{2}_m_noise_at_{3}_Hz.geojson'.format(\\n                            stName, endName, str(noise), str(Hz)), 'w+') as fp:\\n                            json.dump(geojson, fp)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"And now applying this on some real data\\nThese exercises are based on the PyCon tutorial of Brandon Rhodes (so all credit to him!) and the datasets he prepared for that. You can download these data from here: titles.csv and cast.csv and put them in the \\/data folder.\\n\",\"targets\":\"cast = pd.read_csv('data\\/cast.csv')\\ncast.head()\\n\\ntitles = pd.read_csv('data\\/titles.csv')\\ntitles.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# convert to magnitudes\\nimport numpy as np\\n\\n# We'll use Vega spectrum as example\\nvega = Vega()\\nf = lib['HST_WFC3_F110W']\\n# compute the integrated flux through the filter f\\n# note that it work on many spectra at once\\nfluxes = f.get_flux(vega.wavelength, vega.flux, axis=-1)\\n# convert to vega magnitudes\\nmags = -2.5 * np.log10(fluxes.magnitude) - f.Vega_zero_mag\\nprint(\\\"Vega magnitude of Vega in {0:s} is : {1:f} mag\\\".format(f.name, mags))\\nmags = -2.5 * np.log10(fluxes.magnitude) - f.AB_zero_mag\\nprint(\\\"AB magnitude of Vega in {0:s} is : {1:f} mag\\\".format(f.name, mags))\\nmags = -2.5 * np.log10(fluxes.magnitude) - f.ST_zero_mag\\nprint(\\\"ST magnitude of Vega in {0:s} is : {1:f} mag\\\".format(f.name, mags))\\n\\nf.AB_zero_Jy, f.Vega_zero_Jy, f.ST_zero_Jy\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nVega\\nSuppose one has a calibrated spectrum and wants to compute the vega magnitude throug the HST WFC3 F110W passband,\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\".ipynb_checkpoints\\/barriere-capillaire-checkpoint.ipynb\\\".\\nThe first task is:\\nCapacité et longueur de transfert\\nCan you write Python code for it?\\n\",\"targets\":\"\\npente = 0.25\\n\\nQmax = pente * quad(k_vanGenuchten, profileCBL.psiMax, profileMRL.psiMax, args=(mrlaVG, mrlnVG, mrlmVG, mrlksat, mrllVG))[0]\\nL = Qmax \\/ unit_flow\\n\\nprint ('Le débit de transfert maximal dans la barrière capillaire est de', Qmax, 'm²\\/s.')\\nprint ('La longueur de transfert maximale dans la barrière capillaire est de', L, 'm.')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Although statmorph is designed to process all the sources labeled by the segmentation map, in this example we only focus on the main (largest) source found in the image.\\n\",\"targets\":\"# Keep only the largest segment\\nlabel = np.argmax(segm.areas) + 1\\nsegmap = segm.data == label\\nplt.imshow(segmap, origin='lower', cmap='gray')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Same analysis with scipy.stats fxns\\nobserved_nomargin = pd.crosstab(bumpus.survived, bumpus.sex, margins=False)\\nChi2, Pval, Dof, Expected = stats.chi2_contingency(observed_nomargin.values, \\n                                                   correction=False)\\n\\nChi2, Pval, Dof\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n$X^2$-square test of independence using scipy.stats\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"As above, these two variables are defined positional to correspond to both\\nthe distribution and polynomial.\\nFrom the simplified equation above, it can be observed that the fraction of\\nexpected values doesn't depend on neither $c$ nor $t$, and can therefore be\\npre-computed.\\nFor the denominator $\\\\mathbb E[\\\\beta\\\\Phi_n\\\\Phi_k]$, since there are both $\\\\Phi_k$\\nand $\\\\Phi_n$ terms, the full expression can be defined as a two-dimensional\\ntensor:\\n\",\"targets\":\"phi_phi = chaospy.outer(\\n    polynomial_expansion, polynomial_expansion)\\n[polynomial_expansion.shape, phi_phi.shape]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Basic slicing\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\none_dim_array[0]\\n\\ntwo_dim_array[-1, -1]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create AgeGroups for further Analysis\\n'''bins = [0, 25, 50, 75, 100, 120]\\ngroup_names = ['0-25', '25-50', '50-75', '75-100', '100-120']\\nclean_appointment_data['age-group'] = pd.cut(clean_appointment_data['Fixed_Age'], bins, labels=group_names)\\nclean_appointment_data.head()'''\\nclean_appointment_data['Age_rounded'] = np.round(clean_appointment_data['Fixed_Age'], -1)\\n\\n\\ncategories_dict = {0: '0-5',\\n                   10: '5-15',\\n                   20: '15-25',\\n                    30 : '25-35',\\n                    40 : '35-45',\\n                    50 : '45-55',\\n                   60: '55-65',\\n                    70 : '65-75',\\n                    80 : '75-85',\\n                  90: '85-95',\\n                  100: '95-105',\\n                  120: '105-115'}\\n\\nclean_appointment_data['age_group'] = clean_appointment_data['Age_rounded'].map(categories_dict)\\n\\nclean_appointment_data['age_group']\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe Fixed_Age column is created in order to replace the negative value available in the Age column. The newly created Fixed_Age column will help in the proper calculation in the further questions and the results will be perfect and clear too. The negative value (-1) is changed in to a positive value (1) by using the .abd() function.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Basic List Methods\\nIf you are familiar with another programming language, you might start to draw parallels between arrays in another language and lists in Python. Lists in Python however, tend to be more flexible than arrays in other languages for a two good reasons: they have no fixed size (meaning we don't have to specify how big a list will be), and they have no fixed type constraint (like we've seen above).\\nLet's go ahead and explore some more special methods for lists:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Create a new list\\nl = [1,2,3]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Classes\\nThe simplest class\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# define the class\\nclass myclass():\\n    pass\\n\\n# create an instance\\nfoo_instance = myclass()\\nprint(type(foo_instance))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Common formatting tricks\\nThere are hundreds of formatting options available in Matplotlib, many of which you will end up using occasionally. There are a few options, however, that you will use very frequently. Here's a short list...\\n\\nChanging axis limits\\nChanging line colors\\nChanging lines to dashed (for black and white figures)\\nAdding markers to lines\\nMake tick labels point outward instead of inward\\nGet rid of the box surrounding the plot\\nAdding subplot letters, like (a) and (b)\\n\\n...and some examples for how to accomplish all of these things.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Make some data to plot\\nx = np.linspace(0, 2*np.pi)\\ny1 = np.sin(x)\\ny2 = np.cos(x)\\n\\n# First, create an empty figure with 1 subplot\\nfig, ax1 = plt.subplots(1, 1)\\n\\n# Add title and labels\\nax1.set_title('My Plot',fontsize=20)\\nax1.set_xlabel('x',fontsize=20)\\nax1.set_ylabel('y',fontsize=20)\\n\\n# Change axis limits\\nax1.set_xlim([0,2])\\nax1.set_ylim([-1, 2])\\n\\n# Add the lines, changing their color, style, and marker\\nax1.plot(x, y1, 'k--o', label='sin') # Black line, dashed, with 'o' markers\\nax1.plot(x, y2, 'r-^', label='cos') # Red line, solid, with triangle-up markers\\n\\n# Adjust tick marks and get rid of 'box'\\nax1.tick_params(direction='out', top=False, right=False) # Turn ticks out\\nax1.spines['top'].set_visible(False) # Get rid of top axis line\\nax1.spines['right'].set_visible(False) #  Get rid of bottom axis line\\n\\n# Add subplot letter\\nax1.annotate('(a)', (0.01, 0.96), size=12, xycoords='figure fraction')\\n\\n# Add legend\\nax1.legend()\\n\\n# Finally, save the figure as a png file\\nfig.savefig('myfig-formatted.png')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"4. Looking at the data\\nSummaries\\n\",\"targets\":\"prms.Batch.summary_plot_height = 800\\nprms.Batch.summary_plot_width = 900\\n\\n# Plot the charge capacity and the C.E. (and resistance) vs. cycle number (standard plot)\\nb.plot_summaries()\\n\\nfrom bokeh.plotting import figure, show\\nfrom bokeh.models import ColumnDataSource, ColumnarDataSource\\n\\ndata = ColumnDataSource(\\n    pd.DataFrame(\\n        {\\n            \\\"header_en\\\": [1, 2, 3, 4],\\n            \\\"annen\\\": [22.1, 22.2, 22.3, 22.4],\\n            \\\"siste\\\": [1000, 2000, 3000, 4000],\\n        }\\n    )\\n)\\n\\n\\np = figure(\\n    title=\\\"Top Title with Toolbar\\\",\\n    toolbar_location=\\\"above\\\",\\n    plot_width=600,\\n    plot_height=300,\\n)\\np.circle(x=\\\"header_en\\\", y=\\\"annen\\\", source=data)\\n\\nshow(p)\\n\\nb.summary_headers\\n\\n# Show the journal pages\\n# b.experiment.journal.pages.head()\\n\\n# Show the most important part of the journal pages\\nb.view\\n\\n# b.experiment.status()\\n\\nb.summaries.head()\\n\\nsummaries = b.summaries.copy()\\n\\nfrom cellpy.parameters.internal_settings import (\\n    get_headers_summary,\\n    get_headers_normal,\\n    get_headers_step_table,\\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 \\\"03-Pandas_and_DTM\\/00-PandasAndTextAnalysis.ipynb\\\".\\nThe first task is:\\n<a id='apply'><\\/a>\\n3. The apply function\\nWe can also apply a function to each row. To get a word count of a text file we would take the length of the split string like this:\\nlen(text_split)\\nIf we want to do this on every row in our dataframe, we can use the apply() function.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf['word_count'] = df['text_split'].apply(len)\\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 \\\"BAMM.101x\\/Networks_new.ipynb\\\".\\nThe first task is:\\n<h4>Largest connected component subgraph<\\/h4>\\nCan you write Python code for it?\\n\",\"targets\":\"\\nlargest_size=0\\nlargest_graph = None\\nfor g in nx.connected_component_subgraphs(friend_graph):\\n    if len(g) > largest_size:\\n        largest_size = len(g)\\n        largest_graph = g\\nnx.draw(largest_graph)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Why are flights late? Lets look at some delayed flights and the delay causes\\nlate_flights = spark.sql(\\\"\\\"\\\"\\nSELECT\\n  ArrDelayMinutes,\\n  WeatherDelay,\\n  CarrierDelay,\\n  NASDelay,\\n  SecurityDelay,\\n  LateAircraftDelay\\nFROM\\n  on_time_performance\\nWHERE\\n  WeatherDelay IS NOT NULL\\n  OR\\n  CarrierDelay IS NOT NULL\\n  OR\\n  NASDelay IS NOT NULL\\n  OR\\n  SecurityDelay IS NOT NULL\\n  OR\\n  LateAircraftDelay IS NOT NULL\\nORDER BY\\n  FlightDate\\n\\\"\\\"\\\")\\nlate_flights.sample(False, 0.01).show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nInspecting Late Flights\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"By default, Pool creates a fixed number of worker processes and passes jobs to them until there are no more jobs. Setting the maxtasksperchild parameter tells the pool to restart a worker process after it has finished a few tasks, preventing long-running workers from consuming ever more system resources.\\n\",\"targets\":\"import multiprocessing\\n\\n\\ndef do_calculation(data):\\n    return data * 2\\n\\n\\ndef start_process():\\n    print('Starting', multiprocessing.current_process().name)\\n\\n\\nif __name__ == '__main__':\\n    inputs = list(range(10))\\n    print('Input   :', inputs)\\n\\n    builtin_outputs = map(do_calculation, inputs)\\n    print('Built-in:', builtin_outputs)\\n\\n    pool_size = multiprocessing.cpu_count() * 2\\n    pool = multiprocessing.Pool(\\n        processes=pool_size,\\n        initializer=start_process,\\n        maxtasksperchild=2,\\n    )\\n    pool_outputs = pool.map(do_calculation, inputs)\\n    pool.close()  # no more tasks\\n    pool.join()  # wrap up current tasks\\n\\n    print('Pool    :', pool_outputs)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"CrashCourse_Lecture1.ipynb\\\".\\nThe first task is:\\nGreat! 95% accuracy!\\nLet's try it with random labels:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nwilt_svm = sklearn.svm.SVC(C=1)\\nwilt_svm.fit(wilt_train_features, np.random.permutation(wilt_train_labels))\\nprint \\\"Score: %f\\\" % wilt_svm.score(wilt_test_features, np.random.permutation(wilt_test_labels))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Calculate the mean wind speed (column 'wspd'):\\n\\n\\n# Calculate the median of the wind direction (column 'wdir'):\\n\\n\\n# Obtain the maximum difference between two time steps\\n# (column 'wspd_std')\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow, we are skimming this. Later we will see it in a more detailed way:\\nLet's do some simple examples:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Apply Pre-trained Inception V1 model to Images.\\nWe have to convert each image to the size expected by the model checkpoint.\\nThere is no easy way to determine this size from the checkpoint itself.\\nSo we use a preprocessor to enforce this.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport numpy as np\\nimport os\\nimport tensorflow as tf\\n\\ntry:\\n    import urllib2 as urllib\\nexcept ImportError:\\n    import urllib.request as urllib\\n\\nfrom datasets import imagenet\\nfrom nets import inception\\nfrom preprocessing import inception_preprocessing\\n\\nfrom tensorflow.contrib import slim\\n\\nimage_size = inception.inception_v1.default_image_size\\n\\nwith tf.Graph().as_default():\\n    url = 'https:\\/\\/upload.wikimedia.org\\/wikipedia\\/commons\\/7\\/70\\/EnglishCockerSpaniel_simon.jpg'\\n    image_string = urllib.urlopen(url).read()\\n    image = tf.image.decode_jpeg(image_string, channels=3)\\n    processed_image = inception_preprocessing.preprocess_image(image, image_size, image_size, is_training=False)\\n    processed_images  = tf.expand_dims(processed_image, 0)\\n    \\n    # Create the model, use the default arg scope to configure the batch norm parameters.\\n    with slim.arg_scope(inception.inception_v1_arg_scope()):\\n        logits, _ = inception.inception_v1(processed_images, num_classes=1001, is_training=False)\\n    probabilities = tf.nn.softmax(logits)\\n    \\n    init_fn = slim.assign_from_checkpoint_fn(\\n        os.path.join(checkpoints_dir, 'inception_v1.ckpt'),\\n        slim.get_model_variables('InceptionV1'))\\n    \\n    with tf.Session() as sess:\\n        init_fn(sess)\\n        np_image, probabilities = sess.run([image, probabilities])\\n        probabilities = probabilities[0, 0:]\\n        sorted_inds = [i[0] for i in sorted(enumerate(-probabilities), key=lambda x:x[1])]\\n        \\n    plt.figure()\\n    plt.imshow(np_image.astype(np.uint8))\\n    plt.axis('off')\\n    plt.show()\\n\\n    names = imagenet.create_readable_names_for_imagenet_labels()\\n    for i in range(5):\\n        index = sorted_inds[i]\\n        print('Probability %0.2f%% => [%s]' % (probabilities[index] * 100, names[index]))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Amennyiben az oszlop neve nem tartalmaz szóközöket, attribútumként is elérjük.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ngrades.teacher\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# compute dists for each combination (1->5)\\n...\\n\\n# plot results\\n# remember to label your axes!\\n...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow, compute, plot, and label the luminosity distance $d_L(z; \\\\Omega_{m,0}, \\\\Omega_\\\\Lambda)$ for different combinations of $(\\\\Omega_{m,0}, \\\\Omega_\\\\Lambda)$:\\n1. $(0.3, 0.0)$, \\n2. $(0.3, 0.4)$, \\n3. $(0.3, 0.7)$, \\n4. $(0.5, 0.7)$,\\n5. $(0.8, 0.8)$.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"As with the BDF, we can use the long form and the short form.  However, the long form for the OP2 doesn't really add anything.  So, let's just use the short form.\\nBesides massive speed improvements in the OP2 relative to v0.7, this version adds pandas dataframe support.\\n\",\"targets\":\"#op2_filename = r'D:\\\\work\\\\pynastran_0.8.0\\\\models\\\\iSat\\\\ISat_Launch_Sm_Rgd.op2'\\n#op2_filename = r'D:\\\\work\\\\pynastran_0.8.0\\\\models\\\\iSat\\\\ISat_Launch_Sm_4pt.op2'\\nop2_filename = os.path.abspath(os.path.join(pkg_path, '..', 'models', 'iSat', 'ISat_Launch_Sm_4pt.op2'))\\nassert os.path.exists(op2_filename), print_bad_path(op2_filename)\\n\\n# define the input file with a file path\\nop2 = read_op2(op2_filename, build_dataframe=True, debug=False)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"1. Use the \\\"trends.csv\\\" file and csv2rec() to import the data and reproduce this plot:\\n<img align='left' src=\\\"trends.png\\\">\\n\",\"targets\":\"# we can import the CSV data as a numpy rec array\\nfrom matplotlib.pylab import csv2rec\\ntrends = csv2rec('trends.csv')\\n\\nplot(trends.week_start, trends.spring_break, label='spring break')\\nplot(trends.week_start, trends.textbooks, label='texbooks')\\nplot(trends.week_start, trends.norad, label='norad')\\nplot(trends.week_start, trends.skiing, label='skiing')\\nlegend()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Build VectorAssembler stage\\n\",\"targets\":\"feature_columns = ['onehot_' + c for c in categorical_columns]\\nvectorassembler_stage = VectorAssembler(inputCols=feature_columns, outputCol='features')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create the CausalModels\\n\",\"targets\":\"models = []\\nfor data in datasets:\\n    model = CausalModel(\\n                data = data['df'],\\n                treatment = data['treatment_name'],\\n                outcome = data['outcome_name'],\\n                graph = data['gml_graph']\\n            )\\n    models.append(model)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"PageviewAnalysis.ipynb\\\".\\nThe first task is:\\nCreate a column 'date' that combines year, month, and day. Use it as the x axis later when plotting\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf['day'] = '01'\\ndf['date']= df.apply(lambda x:datetime.strptime(\\\"{0} {1} {2}\\\".format(x['year'],x['month'], x['day']), \\\"%Y %m %d\\\"),axis=1)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Alternative: ResNet\\n\\nbasic ideas\\ndepth does matter\\n8x deeper than VGG\\npossible by using shortcuts and skipping final fc layer\\nprevents vanishing gradient problem\\nhttps:\\/\\/keras.io\\/applications\\/#resnet50\\nhttps:\\/\\/medium.com\\/towards-data-science\\/neural-network-architectures-156e5bad51ba\\n\\nhttp:\\/\\/arxiv.org\\/abs\\/1512.03385\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom tensorflow.keras.applications.resnet50 import ResNet50\\n\\n# https:\\/\\/keras.io\\/applications\\/#mobilenet\\n# https:\\/\\/arxiv.org\\/pdf\\/1704.04861.pdf\\nfrom tensorflow.keras.applications.mobilenet import MobileNet\\n\\n# model = ResNet50(classes=10, weights=None, input_shape=(32, 32, 1))\\nmodel = MobileNet(classes=10, weights=None, input_shape=(32, 32, 1))\\n\\nmodel.summary()\\n\\nBATCH_SIZE=10\\nEPOCHS = 20\\n\\nmodel.compile(loss='sparse_categorical_crossentropy',\\n             optimizer='adam',\\n             metrics=['accuracy'])\\n\\n%time history = model.fit(x_train_224, y_train_samples, epochs=EPOCHS, batch_size=BATCH_SIZE, validation_split=0.2, verbose=1)\\n\\nimport pandas as pd\\nfrom matplotlib import pyplot as plt\\n%matplotlib inline\\n\\ndef plot_history(history, samples=10, init_phase_samples=None):\\n    epochs = history.params['epochs']\\n    \\n    acc = history.history['acc']\\n    val_acc = history.history['val_acc']\\n\\n    every_sample =  int(epochs \\/ samples)\\n    acc = pd.DataFrame(acc).iloc[::every_sample, :]\\n    val_acc = pd.DataFrame(val_acc).iloc[::every_sample, :]\\n\\n    fig, ax = plt.subplots(figsize=(20,5))\\n\\n    ax.plot(acc, 'bo', label='Training acc')\\n    ax.plot(val_acc, 'b', label='Validation acc')\\n    ax.set_title('Training and validation accuracy')\\n    ax.legend()\\n\\nplot_history(history)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"AoC2017.4 == [F +] step_zero\\n\",\"targets\":\"define('AoC2017.4 == [[size] [unique size] cleave = +] step_zero')\\n\\nJ('''\\n\\n[[5 1 9 5]\\n [7 5 4 3]\\n [2 4 6 8]] AoC2017.4\\n\\n''')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"!pip install pyrpl #if you look at this file in ipython notebook, just execute this cell to install pyrplockbox\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nShould the directory not be the one of your local github installation, you might have an older version of pyrpl installed. Just delete any such directories other than your principal github clone and everything should work. \\nOption 2: from GitHub using setuptools (beta version)\\nDownload the code manually from https:\\/\\/github.com\\/lneuhaus\\/pyrpl\\/archive\\/master.zip and unzip it or get it directly from git by typing \\n$\\\\texttt{git clone https:\\/\\/github.com\\/lneuhaus\\/pyrpl.git YOUR_DESTINATIONFOLDER}$\\nIn a command line shell, navigate into your new local pyrplockbox directory and execute\\n$\\\\texttt{python setup.py install}$\\nThis copies the files into the side-package directory of python. The setup should make sure that you have the python libraries paramiko (http:\\/\\/www.paramiko.org\\/installing.html) and scp (https:\\/\\/pypi.python.org\\/pypi\\/scp) installed. If this is not the case you will get a corresponding error message in a later step of this tutorial. \\nOption 1: with pip (coming soon)\\nIf you have pip correctly installed, executing the following line in a command line should install pyrplockbox and all dependencies: \\n$\\\\texttt{pip install pyrpl}$\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#wyrównanie do nawiasu otwierającego\\nfoo = moja_dluga_funkcja(zmienna_jeden, zmienna_dwa\\n                         zmienna_trzy, zmienna_cztery)\\n\\n# zwiększone wcięcia aby rozróżnić funkcję od ciała funkcji\\ndef moja_dluga_funkcja(\\n        zmienna_jeden, zmienna_dwa, zmienna_trzy,\\n        zmienna_cztery):\\n    print(zmienna_jeden)\\n\\nfoo = moja_dluga_funkcja(\\n    zmienna_jeden, zmienna_dwa,\\n    zmienna_trzy, zmienna_cztery)\\n\\n# Może być w tym przypadku inna ilość wcięć niż 4\\nfoo = moja_dluga_funkcja(\\n  zmienna_jeden, zmienna_dwa,\\n  zmienna_trzy, zmienna_cztery)\\n\\nmoja_lista = [\\n    1, 2, 3,\\n    4, 5, 6,\\n    ]\\n\\nwynik = funkcja_przyjmujaca_argumenty(\\n    'a', 'b', 'c',\\n    'd', 'e', 'f',\\n    )\\n\\n# dozwolone też wyrównanie z początkiem lini otwierającej wielowierszową konstrukcję\\n\\nmoja_lista = [\\n    1, 2, 3,\\n    4, 5, 6,\\n]\\n\\nwynik = funkcja_przyjmujaca_argumenty(\\n    'a', 'b', 'c',\\n    'd', 'e', 'f',\\n)\\n\\nprzychod = (zarobki_brutto\\n            + zwrot_z_podatku\\n            + (dywidendy - podatek_od_dywidend)\\n            - ubezpieczenie_samochodu\\n            - kredyt_studencki)\\n\\n#Dobrze:\\nimport os\\nimport sys\\n\\n#Źle:  \\nimport sys, os\\n    \\n#Dobrze:\\nfrom subprocess import Popen, PIPE \\n\\n\\\"\\\"\\\"Przykładowy moduł.\\n\\nCoś tutaj się dzieje.\\n\\\"\\\"\\\"\\n\\nfrom __future__ import jakiś_moduł\\n\\n__all__ = ['a', 'b', 'c']\\n__version__ = '0.1'\\n__author__ = 'Andrzej Krawczyk'\\n\\nimport os\\nimport sys\\n\\n#Dobrze:\\ndef average(count, length=5):\\n    return foo(c=count, l=length)\\n\\n#Źle:\\ndef complex(count, length = 5):\\n    return foo(c = count, l = length)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUruchomiene Aplikacji\\n\\n\\nZ poziomu konsoli\\n    > python program.py\\n\\n\\nShebang (Unix)\\n    > #!\\/usr\\/bin\\/env python3\\n\\n\\nPrawa wykonywania\\n    > chmod u+x program.py\\n    >\\n\\n\\nInteraktywny Interpreter\\n    > ipython\\n\\n\\nSkładnia\\n\\ninstrukcje nie są zakończone średnikiem\\nbloki kodu są definiowane przez wcięcia\\nwiele angielskich słów\\nkomentarz #\\nzminimalizowany zbiór instrukcji\\n\\nPEP8\\n\\nwcięcia 4 spacje\\nDługość lini 79\\nImportowanie per linia, na poczatku modułu, kolejność priorytetowa\\n(2 + 3), 4\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"1.4.2.3 Conclusion\\nOver the years the repartition has changed. As we are doing predictions with user data from July 2014, this changes may require us to focus on the most recent data during training. It is most likely to have similar pattern than test data.\\n1.4.3 Account Creation Analysis\\nWe want to evaluate the quantity of data we would have left if we only consider the N-last months of the data.\\nWe have seen that the \\\"early users\\\" are very different of the actual ones. Let's see how much of data we can delete of the dataset.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntmp_df = df_output_by_year_and_month[['country_destination','year_month_account_created']].sort_values(\\n    by=\\\"year_month_account_created\\\"\\n)\\n\\ntmp_df = tmp_df.groupby([\\\"year_month_account_created\\\"]).agg(\\\"count\\\")\\ntmp_df.head(n=4)\\n\\n# Plot Data\\nx_data = [str(x) for x in tmp_df[\\\"country_destination\\\"].index.values]\\ny_data = tmp_df[\\\"country_destination\\\"].values\\n\\np = bk_plt.figure(plot_width=980, plot_height=400, y_range=[0, y_data.max()+1000], x_range=x_data)\\n\\np.line(x_data, y_data, line_width=2)\\np.circle(x_data, y_data, fill_color=\\\"white\\\", size=8)\\n\\n\\n# Draw a line when X% of the users of the dataset have sign-up\\nsplit_1 = 20 # 80% left\\nsplit_2 = 30 # 70% left\\nsplit_3 = 50 # 50% left\\nsplit_4 = 70 # 30% left\\n\\nthrs_value_1 = 213450 * split_1 \\/ 100\\nthrs_value_2 = 213450 * split_2 \\/ 100\\nthrs_value_3 = 213450 * split_3 \\/ 100\\nthrs_value_4 = 213450 * split_4 \\/ 100\\n\\nindex_1 = 0\\nindex_2 = 0\\nindex_3 = 0\\nindex_4 = 0\\n\\ntmp_sum = 0\\nfor val in y_data:\\n    tmp_sum += val\\n    \\n    if tmp_sum <= thrs_value_1:\\n        index_1 += 1     \\n        index_2 += 1\\n        index_3 += 1\\n        index_4 += 1\\n    elif tmp_sum <= thrs_value_2:    \\n        index_2 += 1\\n        index_3 += 1\\n        index_4 += 1\\n    elif tmp_sum <= thrs_value_3:\\n        index_3 += 1\\n        index_4 += 1\\n    elif tmp_sum <= thrs_value_4:\\n        index_4 += 1\\n    else:\\n        break\\n           \\n        \\nvline_1 = bk_md.Span(location=index_1, dimension='height', line_color='blue', line_width=3) # 80% Data Left\\nvline_2 = bk_md.Span(location=index_2, dimension='height', line_color='green', line_width=3) # 70% Data Left\\nvline_3 = bk_md.Span(location=index_3, dimension='height', line_color='orange', line_width=3) # 50% Data Left\\nvline_4 = bk_md.Span(location=index_4, dimension='height', line_color='red', line_width=3) # 30% Data Left\\n\\np.renderers.extend([vline_1, vline_2, vline_3, vline_4])\\n\\n# We set label orientation\\nfrom math import pi\\np.xaxis.major_label_orientation = pi\\/2\\n\\n# We display the graph\\nbk_plt.show(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 \\\"11.Introduction_to_Numpy.ipynb\\\".\\nThe first task is:\\nTranslating from Python to English, \\\"call the randint module from the random module of numpy, then select 20 numbers between 0 and 999 at random, and assign that to an array named rand_arr i.e. 0 is included, 1000 is excluded.\\n<img src=\\\"images\\/simples.gif\\\"> <br><br>\\nCan you write Python code for it?\\n\",\"targets\":\"\\nrand_arr.reshape(5,4)\\n\\nrand_arr.reshape(4,5)\\n\\nrand_arr.reshape(2,10)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Adding wind vectors can be done with the incwind argument.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntest.map2d(\\\"t\\\",incwind=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#Weight matrices generated by the neural network after training\\n\\n#Maps the label vectors to the neuron activity of the ensemble\\nlabel_weights = cPickle.load(open(\\\"label_weights1000.p\\\", \\\"rb\\\"))\\n#Maps the activity of the neurons to the visual representation of the image\\nactivity_to_img_weights = cPickle.load(open(\\\"activity_to_img_weights_scale1000.p\\\", \\\"rb\\\"))\\n#Maps the activity of the neurons of an image with the activity of the neurons of an image scaled\\nscale_up_weights = cPickle.load(open(\\\"scale_up_weights1000.p\\\", \\\"rb\\\"))\\nscale_down_weights = cPickle.load(open(\\\"scale_down_weights1000.p\\\", \\\"rb\\\"))\\n\\n#Create the pointers for the numbers\\ntemp = np.diag([1]*10)\\n\\nZERO = temp[0]\\nONE =  temp[1]\\nTWO =  temp[2]\\nTHREE= temp[3]\\nFOUR = temp[4]\\nFIVE = temp[5]\\nSIX =  temp[6]\\nSEVEN =temp[7]\\nEIGHT= temp[8]\\nNINE = temp[9]\\n\\nlabels =[ZERO,ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE]\\n\\n#Visualize the one hot representation\\nprint(ZERO)\\nprint(ONE)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLoad the weight matrices from the training\",\"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\\/Using nbconvert as a Library.ipynb\\\".\\nThe first task is:\\nNotice that base64 images are not embeded, but instead there are file name like strings.  The strings actually are (configurable) keys that map to the binary data in the resources dict.\\nNote, if you write an RST Plugin, you are responsible for writing all the files to the disk (or uploading, etc...) in the right location.  Of course, the naming scheme is configurable.\\nAs an exercise, this notebook will show you how to get one of those images.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nlist(resources['outputs'])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create an input pipeline\\nTypically, you will use a two step proces to build the pipeline. Step one is to define the columns of data; i.e., which column we're predicting for, and the default values.  Step 2 is to define two functions - a function to define the features and label you want to use and a function to load the training data.  Also, note that pickup_datetime is a string and we will need to handle this in our feature engineered model.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nCSV_COLUMNS = [\\n    \\\"fare_amount\\\",\\n    \\\"pickup_datetime\\\",\\n    \\\"pickup_longitude\\\",\\n    \\\"pickup_latitude\\\",\\n    \\\"dropoff_longitude\\\",\\n    \\\"dropoff_latitude\\\",\\n    \\\"passenger_count\\\",\\n    \\\"key\\\",\\n]\\nLABEL_COLUMN = \\\"fare_amount\\\"\\nSTRING_COLS = [\\\"pickup_datetime\\\"]\\nNUMERIC_COLS = [\\n    \\\"pickup_longitude\\\",\\n    \\\"pickup_latitude\\\",\\n    \\\"dropoff_longitude\\\",\\n    \\\"dropoff_latitude\\\",\\n    \\\"passenger_count\\\",\\n]\\nDEFAULTS = [[0.0], [\\\"na\\\"], [0.0], [0.0], [0.0], [0.0], [0.0], [\\\"na\\\"]]\\nDAYS = [\\\"Sun\\\", \\\"Mon\\\", \\\"Tue\\\", \\\"Wed\\\", \\\"Thu\\\", \\\"Fri\\\", \\\"Sat\\\"]\\n\\n# A function to define features and labesl\\ndef features_and_labels(row_data):\\n    for unwanted_col in [\\\"key\\\"]:\\n        row_data.pop(unwanted_col)\\n    label = row_data.pop(LABEL_COLUMN)\\n    return row_data, label\\n\\n\\n# A utility method to create a tf.data dataset from a Pandas Dataframe\\ndef load_dataset(pattern, batch_size=1, mode=\\\"eval\\\"):\\n    dataset = tf.data.experimental.make_csv_dataset(\\n        pattern, batch_size, CSV_COLUMNS, DEFAULTS\\n    )\\n    dataset = dataset.map(features_and_labels)  # features, label\\n    if mode == \\\"train\\\":\\n        dataset = dataset.shuffle(1000).repeat()\\n        # take advantage of multi-threading; 1=AUTOTUNE\\n        dataset = dataset.prefetch(1)\\n    return dataset\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Creating the next_fn\\nWe now use our client and server update code to write the actual algorithm. We will first turn our client_update into a tff.tf_computation that accepts a client datasets and server weights, and outputs an updated client weights tensor.\\nWe will need the corresponding types to properly decorate our function. Luckily, the type of the server weights can be extracted directly from our model.\\n\",\"targets\":\"whimsy_model = model_fn()\\ntf_dataset_type = tff.SequenceType(whimsy_model.input_spec)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"13. Change the age in row 'f' to 1.5.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndf.loc['f', 'age'] = 1.5\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"4. Making the plot easier to read and more informative\\n<p>While the plot above is informative enough, it can be improved. Bitcoin is too big, and the other coins are hard to distinguish because of this. Instead of the percentage, let's use a log<sup>10<\\/sup> scale of the \\\"raw\\\" capitalization. Plus, let's use color to group similar coins and make the plot more informative<sup>1<\\/sup>. <\\/p>\\n<p>For the colors rationale: bitcoin-cash and bitcoin-gold are forks of the bitcoin <a href=\\\"https:\\/\\/en.wikipedia.org\\/wiki\\/Blockchain\\\">blockchain<\\/a><sup>2<\\/sup>. Ethereum and Cardano both offer Turing Complete <a href=\\\"https:\\/\\/en.wikipedia.org\\/wiki\\/Smart_contract\\\">smart contracts<\\/a>. Iota and Ripple are not minable. Dash, Litecoin, and Monero get their own color.<\\/p>\\n<p><sup>1<\\/sup> <em>This coloring is a simplification. There are more differences and similarities that are not being represented here.<\\/em><\\/p>\\n<p><sup>2<\\/sup> <em>The bitcoin forks are actually <strong>very<\\/strong> different, but it is out of scope to talk about them here. Please see the warning above and do your own research.<\\/em><\\/p>\\n\",\"targets\":\"# Colors for the bar plot\\nCOLORS = ['orange', 'green', 'orange', 'cyan', 'cyan', 'blue', 'silver', 'orange', 'red', 'green']\\n\\n# Plotting market_cap_usd as before but adding the colors and scaling the y-axis  \\nax = cap10.plot.bar(x='id',y='market_cap_perc',title=TOP_CAP_TITLE, color=COLORS, log=True)\\n\\n# Annotating the y axis with 'USD'\\nax.set_ylabel(\\\"USD\\\")\\n\\n# Final touch! Removing the xlabel as it is not very informative\\nax.set_xlabel('')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Calculating event distribution for a sphere\\nWe can also use the event_distribution for a sample with a sphere boundary. To do this, simply set boundary='sphere' when setting the sample parameters above. See montecarlo_tutorial.ipynb for additional optional parameters that can be set for the sphere case. \\nCalculate event distribution\\nInput the output from calc_refl_trans() into a function that calculates the how the reflectance is distributed across all the events\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nrefl_events, trans_events = ed.calc_refl_trans_event(refl_per_traj, \\n                                                     inc_refl_per_traj, \\n                                                     trans_per_traj, \\n                                                     refl_indices, \\n                                                     trans_indices, \\n                                                     nevents)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"ANTLR4-Python\\/LR-Parser-Generator\\/LR-Table-Generator.ipynb\\\".\\nThe first task is:\\nThe function to_rule(self) turns the extended marked rule self into  a GrammarRule, i.e. the extended marked rule\\n$$ c \\\\rightarrow \\\\alpha \\\\bullet \\\\beta: L $$\\nis turned into the grammar rule\\n$$ c \\\\rightarrow \\\\alpha\\\\, \\\\beta. $$\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef to_rule(self):\\n    return GrammarRule(self.mVariable, self.mAlpha + self.mBeta)\\n\\nExtendedMarkedRule.to_rule = to_rule\\ndel to_rule\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Analyze with OPS\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nanalysis_file = paths.AnalysisStorage(\\\"one_way.nc\\\")\\n\\nscheme = analysis_file.schemes[0]\\nscheme.move_summary(analysis_file.steps)\\n\\nimport openpathsampling.visualize as ops_vis\\nfrom IPython.display import SVG\\nhistory = ops_vis.PathTree(\\n    analysis_file.steps,\\n    ops_vis.ReplicaEvolution(replica=0)\\n)\\n# switch to the \\\"boxcar\\\" look for the trajectories\\nhistory.options.movers['default']['new'] = 'single'\\nhistory.options.css['horizontal_gap'] = True\\nSVG(history.svg())\\n\\npath_lengths = [len(step.active[0].trajectory) for step in analysis_file.steps]\\nplt.hist(path_lengths, alpha=0.5);\\n\\ncv_x = analysis_file.cvs['x']\\n# load the active trajectory as storage.steps[step_num].active[replica_id]\\nplt.plot(cv_x(analysis_file.steps[2].active[0]), 'o-');\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\".ipynb_checkpoints\\/AAG_16 copy-checkpoint.ipynb\\\".\\nThe first task is:\\nFuture Work & Vision\\n$\\\\Longrightarrow$ Provide more accessible alternatives to spatial optimization & GIS\\n$\\\\Longrightarrow$ Develop a python library to bring together spatial analysis & spatial optimization in one package [spanoptpy], potentially incorporating:\\n|QGIS|  PySAL  |  NetworkX  |  Pandas & QGrid |  GeoPandas  |  NumPy \\/ SciPy  |  Shapely  |  Bokeh | CyLP | PostgreSQL & PostGIS\\n|----|---------|-------------------------------------------------------------------------\\n|GIS|network analysis|network analysis|data frames|geo dataframes|scientific computing|geometric objects|visualizations|optimization | DBMS\\n$\\\\Longrightarrow$ Need PySAL.Network to be able to handle larger networks\\n$\\\\Longrightarrow$ Intergration with PostgreSQL & PostGIS for data storage\\n$\\\\Longrightarrow$ Develop functionality within a Linux environment\\n$\\\\Longrightarrow$  scipy.spatial.cKDTree(dist_matrix)\\n&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\\\\ast$  query_ball_point() for close neighbors of the selected sites\\n$\\\\Longrightarrow$ Master CyLP from COIN-OR or develop an open-source optimization suite\\n\\ninterface with CLP, CBC, CGL\\n[ http:\\/\\/mpy.github.io\\/CyLPdoc\\/ ]\\nrelatively steep learning curve \\nComputational Optimization Infrastructure for Operations Research\\n[ http:\\/\\/www.coin-or.org ]\\n\\n$\\\\ast$ CyLP example\\nMinimize\\n&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $ 3x + 2y $\\nSubject To\\n&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $ x \\\\geq 3$\\n&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $ y \\\\geq 5$\\n&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; $ x - y \\\\leq 20$\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Gurobi\\nm = gbp.Model()\\nm.setParam('OutputFlag', False) \\nx = m.addVar(vtype=gbp.GRB.CONTINUOUS, name='x')\\ny = m.addVar(vtype=gbp.GRB.CONTINUOUS, name='y')\\nm.update()\\nm.setObjective(3*x + 2*y, gbp.GRB.MINIMIZE)\\nm.addConstr(x >= 3)\\nm.addConstr(y >= 5)\\nm.addConstr(x - y <= 20)\\nm.optimize()\\n#m.write('path_m.lp')\\nprint m.objVal\\nprint m.getVars()\\n\\n# CyLP\\ns = CyClpSimplex()\\nx = s.addVariable('x', 1)\\ny = s.addVariable('y', 1)\\ns.addConstraint(x >= 3)\\ns.addConstraint(y >= 5)\\ns.addConstraint(x - y <= 20)\\ns.objective = 3 * x + 2 * y\\ns.primal()\\n#s.writeLp('path_s')\\nprint s.objectiveValue\\nprint s.primalVariableSolution\\nprint 'Gurobi & CLP Objective Values match? --> ', m.objVal == s.objectiveValue\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Train PCA on training data set\\nX_pca_train = pca.fit_transform(X_train)\\n\\n# apply to test set\\nX_pca_test = pca.transform(X_test)\\n\\n# we'll leave the test set for later.\\n\\n# instantiate the random forest classifier:\\nRFmod = RandomForestClassifier()\\n\\n# do a grid search over the free random forest parameters:\\npars = {\\\"n_estimators\\\": [10, 100, 300],\\n        \\\"max_features\\\": [1, 2], \\n        \\\"min_samples_leaf\\\": [1,10]}\\n\\ngrid_results = GridSearchCV(RandomForestClassifier(), \\n                            pars,\\n                            cv = 5)\\n\\ngrid_results.fit(X_pca_train, y_train)\\n\\n\\n\\ngrid_results.best_score_\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise 5: Re-do the classification on the PCA components instead of the original features.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As you might expect, the posterior distribution for A is shifted to the right and the posterior distribution for B is shifted to the left.\\nWe can summarize the results by computing the posterior means:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nprior.mean()\\n\\nprint(marginal_A.mean(), marginal_B.mean())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# TODO: Import 'train_test_split'\\nfrom sklearn.cross_validation import train_test_split\\n\\n# TODO: Shuffle and split the data into training and testing subsets\\nX_train, X_test, y_train, y_test = train_test_split(features, prices, test_size=0.2, random_state=0)\\n\\n# Success\\nprint \\\"Training and testing split was successful.\\\"\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAnswer: According to the R^2 result above, the model successfull captures the variations in the target variables. \\nImplementation: Shuffle and Split Data\\nYour next implementation requires that you take the Boston housing dataset and split the data into training and testing subsets. Typically, the data is also shuffled into a random order when creating the training and testing subsets to remove any bias in the ordering of the dataset.\\nFor the code cell below, you will need to implement the following:\\n- Use train_test_split from sklearn.cross_validation to shuffle and split the features and prices data into training and testing sets.\\n  - Split the data into 80% training and 20% testing.\\n  - Set the random_state for train_test_split to a value of your choice. This ensures results are consistent.\\n- Assign the train and testing splits to X_train, X_test, y_train, and y_test.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#@test {\\\"skip\\\": true}\\ntry:\\n  %%time\\nexcept:\\n  pass\\n\\n# Reset the train step\\ntf_agent.train_step_counter.assign(0)\\n\\n# Evaluate the agent's policy once before training.\\navg_return = get_eval_metrics()[\\\"AverageReturn\\\"]\\nreturns = [avg_return]\\n\\nfor _ in range(num_iterations):\\n  # Training.\\n  collect_actor.run()\\n  loss_info = agent_learner.run(iterations=1)\\n\\n  # Evaluating.\\n  step = agent_learner.train_step_numpy\\n\\n  if eval_interval and step % eval_interval == 0:\\n    metrics = get_eval_metrics()\\n    log_eval_metrics(step, metrics)\\n    returns.append(metrics[\\\"AverageReturn\\\"])\\n\\n  if log_interval and step % log_interval == 0:\\n    print('step = {0}: loss = {1}'.format(step, loss_info.loss.numpy()))\\n\\nrb_observer.close()\\nreverb_server.stop()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nさまざまなメトリクスの他の標準実装については、metrics moduleをご覧ください。\\nエージェントのトレーニング\\nトレーニングループには、環境からのデータ収集とエージェントのネットワークの最適化の両方が含まれます。途中で、エージェントのポリシーを時々評価して、状況を確認します。\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create a symmetric matrix\\nS = A + A.T\\n\\n# Compute eigenvectors of S and print eigenvalues\\nlmbda, U = np.linalg.eig(S)\\nprint(lmbda)\\n\\n# R matrix\\nR = U.T\\n\\n# Diagonalise S\\nLambda = R.dot(S.dot(R.T))\\nprint(Lambda)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNote that the matrix Lambda ($\\\\boldsymbol{\\\\Lambda}$) is diagonal, and the diagonal entries are the eigenvalues.\\nDiagonalisation of symmetric matrices\\nIn the above, we have only required that the eigenvectors be linearly independent. In this case, the matrix $\\\\boldsymbol{U}$ can be inverted. For a symmetric matrix, we have proved in the lecture notes that the eigenvectors are orthogonal. Therefore, for a real, symmetric matrix $\\\\boldsymbol{S}$, if the eigenvectors have been normalised the matrix $\\\\boldsymbol{U}$ is an orthogonal matrix. In this case \\n$$\\n\\\\boldsymbol{S} = \\\\boldsymbol{U} \\\\boldsymbol{\\\\Lambda} \\\\boldsymbol{U}^{T}\\n$$\\nIn terms of the notation used for the rotation of matrices, $\\\\boldsymbol{R} = \\\\boldsymbol{U}^{T}$, where in this case $\\\\boldsymbol{R}$ is used to change the basis to one aligned with the eigenvectors:\\n$$\\n\\\\boldsymbol{S} = \\\\boldsymbol{R}^{T} \\\\boldsymbol{\\\\Lambda} \\\\boldsymbol{R}\\n$$\\nSince $\\\\boldsymbol{R}$ is an orthogonal matrix,\\n$$\\n\\\\boldsymbol{\\\\Lambda} = \\\\boldsymbol{R} \\\\boldsymbol{S} \\\\boldsymbol{R}^{T}\\n$$\\nWe can test this for a given matrix:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# @title An example for loading Cats vs Dongs noisy label datasets\\ntask_name = 'cats_vs_dogs'\\n\\n# One of ['low', 'medium', 'high']\\nnoise_level = 'medium'\\n\\n# One of ['train', 'valid']. The `valid` split should be used for\\n# hyperparameter tuning. The model should be tested on the original test\\n# slipt for these tasks.\\nsplit = 'train'\\n\\n# We have 10 rater models for Cats vs Dogs.\\nnum_raters = 10\\n\\ndirectory = os.path.join(root_dir, task_name, noise_level, split) + '*'\\nraw_image_dataset = tf.data.TFRecordDataset(tf.io.gfile.glob(directory))\\n\\n# Create a dictionary describing the features.\\nimage_feature_description = {\\n    # noisy labels from all the raters\\n    'noisy_labels': tf.io.FixedLenFeature([num_raters], tf.int64),\\n    # the IDs of rater models\\n    'rater_ids': tf.io.FixedLenFeature([num_raters], tf.string),\\n    # filename of the image\\n    'image\\/filename': tf.io.FixedLenFeature([1], tf.string),\\n}\\n\\ndef _parse_image_function(example_proto):\\n  # Parse the input tf.train.Example proto using the dictionary above.\\n  return tf.io.parse_single_example(example_proto, image_feature_description)\\n\\nparsed_image_dataset = raw_image_dataset.map(_parse_image_function)\\n\\nfor features in parsed_image_dataset.take(1):\\n  # Check the IDs of the rater models. The rater IDs are the same for all the\\n  # examples in the dataset.\\n  rater_ids = features['rater_ids']\\n  rater_id_string = [r.numpy().decode('utf-8') for r in rater_ids]\\n  print('The IDs of the rater models for this dataset are:')\\n  print(rater_id_string)\\n  print('Image filename:')\\n  print(features['image\\/filename'][0].numpy().decode('utf-8'))\\n  noisy_labels = features['noisy_labels'].numpy()\\n  print('The noisy labels from the rater models are:')\\n  print(noisy_labels)\\n\\n# @title An example for loading rater features\\nfor task_name in ['cifar10', 'cifar100', 'patch_camelyon', 'cats_vs_dogs']:\\n  for noise_level in ['low', 'medium', 'high']:\\n    dir = os.path.join(root_dir, task_name, noise_level, 'rater_features.json')\\n    with tf.io.gfile.GFile(dir, 'rb') as fj:\\n     ...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nCats vs Dogs noisy label datasets\\nDownload size\\n*   2.4MB for each of the low, medium, and high noise datasets.\\nNumber of examples\\n*   train: 9302, valid: 1184, for each of the low, medium, and high noise datasets.\\nBoth the train and valid splits are subsampled from the original Cats vs Dogs dataset.\\nData features\\n*   \\\"noisy_labels\\\": the noisy label given by rater models, a list of 10 tf.int64 integers. Label 0 for cats, 1 for dogs.\\n*   \\\"rater_ids\\\": the ID of the rater models, a list of 10 tf.string.\\n*   \\\"image\\/filename\\\": the filename of the image, corresponding to the filename in the original Cats vs Dogs dataset, tf.string.\\nRater features\\n*   model_name: name of the model\\n*   accuracy: accuracy of the rater model on the rater validation set\\n*   loss: loss of the rater model on the rater validation set\\n*   mAP: the mean average precision of the rater model on the rater validation set\\n*   auc_PR: the area under curve--precision recall of the rater model on the rater validation set\\n*   auc_ROC: the area under curve--ROC of the rater model on the rater validation set\\n*   experience: the total number of data that the rater model has seen during training\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"As you see, the loss and error rate is decreasing as the finetuning progresses.\\nLet's see the classification result after finetuning.\\n\",\"targets\":\"_, _ = run_validation(pred_valid, loss_valid, top_1_error_valid, input_image_valid, data_iterator_valid, with_visualized=True)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Number of Epochs\\nnum_epochs = 200\\n\\n# Batch Size\\nbatch_size = 128\\n\\n# RNN Size\\nrnn_size = 256\\n\\n# Embedding Dimension Size\\nembed_dim = 300\\n\\n# Sequence Length\\nseq_length = 20\\n\\n# Learning Rate\\nlearning_rate = 0.01\\n\\n# Show stats for every n number of batches\\nshow_every_n_batches = 13\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\nsave_dir = '.\\/save'\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\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 embed_dim to the size of the embedding.\\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.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"3. Examples of training Logit-Linear \\/ GBM \\/ DNN predictors\\nNext we train 3 models on all 4 CNN collections with the best hyperparameter configurations we found during our studies (documented in Table 2 and Section 4 of the paper).\\nFirst, we load the best hyperparameter configurations we found.\\nThe file best_configs.json contains a list. \\nEach entry of that list corresponds to the single hyperparameter configuration. \\nIt consists of: \\n(1) name of the CNN collection (mnist\\/fashion mnist\\/cifar10\\/svhn) \\n(2) predictor type (linear\\/dnn\\/lgbm)\\n(3) type of inputs, (refer to Table 2)\\n(4) value of MSE you will get training with these settings, \\n(5) dictionary of \\\"parameter name\\\"-> \\\"parameter value\\\" for the given type of predictor.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nwith gfile.GFile(os.path.join(CONFIGS_PATH_BASE, 'best_configs.json'), 'r') as file:\\n  best_configs = json.load(file)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Compute now the mean square error (MSE) and the negative log-predictive density (NLPD) with the following code:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# <SOL>\\nMSE = np.mean((m_y - Ytest)**2)\\nNLPD = 0.5 * np.mean(((Ytest - m_y)**2)\\/v_y) + 0.5*np.log(2*np.pi*v_y)\\n# <\\/SOL>\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create ML dataset using Dataflow\\nLet's use Cloud Dataflow to read in the BigQuery data, do some preprocessing, and write it out as CSV files.\\nInstead of using Beam\\/Dataflow, I had three other options:\\n\\nUse Cloud Dataprep to visually author a Dataflow pipeline. Cloud Dataprep also allows me to explore the data, so we could have avoided much of the handcoding of Python\\/Seaborn calls above as well!\\nRead from BigQuery directly using TensorFlow.\\nUse the BigQuery console (http:\\/\\/bigquery.cloud.google.com) to run a Query and save the result as a CSV file. For larger datasets, you may have to select the option to \\\"allow large results\\\" and save the result into a CSV file on Google Cloud Storage. \\n\\nHowever, in this case, I want to do some preprocessing, modifying data so that we can simulate what is known if no ultrasound has been performed. If I didn't need preprocessing, I could have used the web console. Also, I prefer to script it out rather than run queries on the user interface, so I am using Cloud Dataflow for the preprocessing.\\nThe preprocess function below includes an arugment in_test_mode. When this is set to True, running preprocess initiates a local Beam job. This is helpful for quickly debugging your pipeline and ensuring it works before submitting a job to the Cloud.  Setting in_test_mode to False will launch a processing that is happening on the Cloud. Go to the GCP webconsole to the Dataflow section and monitor the running job. It took about 20 minutes for me.\\nIf you wish to continue without doing this step, you can copy my preprocessed output:\\n<pre>\\ngsutil -m cp -r gs:\\/\\/cloud-training-demos\\/babyweight\\/preproc gs:\\/\\/YOUR_BUCKET\\/\\n<\\/pre>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport apache_beam as beam\\nimport datetime, os\\n\\ndef to_csv(rowdict):\\n    # Pull columns from BQ and create a line\\n    import hashlib\\n    import copy\\n    CSV_COLUMNS = \\\"weight_pounds,is_male,mother_age,plurality,gestation_weeks\\\".split(',')\\n\\n    # Create synthetic data where we assume that no ultrasound has been performed\\n    # and so we don\\\"t know sex of the baby. Let\\\"s assume that we can tell the difference\\n    # between single and multiple, but that the errors rates in determining exact number\\n    # is difficult in the absence of an ultrasound.\\n    no_ultrasound = copy.deepcopy(rowdict)\\n    w_ultrasound = copy.deepcopy(rowdict)\\n\\n    no_ultrasound[\\\"is_male\\\"] = \\\"Unknown\\\"\\n    if rowdict[\\\"plurality\\\"] > 1:\\n        no_ultrasound[\\\"plurality\\\"] = \\\"Multiple(2+)\\\"\\n    else:\\n        no_ultrasound[\\\"plurality\\\"] = \\\"Single(1)\\\"\\n\\n    # Change the plurality column to strings\\n    w_ultrasound[\\\"plurality\\\"] = [\\\"Single(1)\\\", \\\"Twins(2)\\\", \\\"Triplets(3)\\\", \\\"Quadruplets(4)\\\", \\\"Quintuplets(5)\\\"][rowdict[\\\"plurality\\\"] - 1]\\n\\n    # Write out two rows for each input row, one with ultrasound and one without\\n    for result in [no_ultrasound, w_ultrasound]:\\n        data = ','.join([str(result[k]) if k in result else \\\"None\\\" for k in CSV_COLUMNS])\\n        yield str(\\\"{}\\\".format(data))\\n  \\ndef preprocess(in_test_mode):\\n    import shutil, os, subprocess\\n    job_name = \\\"preprocess-babyweight-features\\\" + \\\"-\\\" + datetime.datetime.now().strftime(\\\"%y%m%d-%H%M%S\\\")\\n\\n    if in_test_mode:\\n        print(\\\"Launching local job ... hang on\\\")\\n        OUTPUT_DIR = \\\".\\/preproc\\\"\\n        shutil.rmtree(OUTPUT_DIR, ignore_errors=True)\\n        os.makedirs(OUTPUT_DIR)\\n    else:\\n        print(\\\"Launching Dataflow job {} ... hang on\\\".format(job_name))\\n        OUTPUT_DIR = \\\"gs:\\/\\/{0}\\/babyweight\\/preproc\\/\\\".format(BUCKET)\\n        try:\\n            subprocess.check_call(\\\"gsutil -m rm -r {}\\\".format(OUTPUT_DIR).split())\\n        except:\\n            pass\\n\\n    options = {\\n        \\\"staging_location\\\": os.path.join(OUTPUT_DIR, \\\"tmp\\\", \\\"staging\\\"),\\n        \\\"temp_location\\\": os.path.join(OUTPUT_DIR,...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"4.B Using the pywt.wavedec() for the decomposition of a signal into the frequency sub-bands\\n(and reconstrucing it again)\\n\",\"targets\":\"time = np.linspace(0, 1, num=2048)\\nchirp_signal = np.sin(250 * np.pi * time**2)\\n\\ncoefficients_level1 = pywt.wavedec(chirp_signal, 'db2', 'smooth', level=1)\\ncoefficients_level2 = pywt.wavedec(chirp_signal, 'db2', 'smooth', level=2)\\ncoefficients_level3 = pywt.wavedec(chirp_signal, 'db2', 'smooth', level=3)\\ncoefficients_level4 = pywt.wavedec(chirp_signal, 'db2', 'smooth', level=4)\\ncoefficients_level5 = pywt.wavedec(chirp_signal, 'db2', 'smooth', level=5)\\n\\nreconstructed_signal_level1 = pywt.waverec(coefficients_level1, 'db2', 'smooth')\\nreconstructed_signal_level2 = pywt.waverec(coefficients_level2, 'db2', 'smooth')\\nreconstructed_signal_level3 = pywt.waverec(coefficients_level3, 'db2', 'smooth')\\nreconstructed_signal_level4 = pywt.waverec(coefficients_level4, 'db2', 'smooth')\\nreconstructed_signal_level5 = pywt.waverec(coefficients_level5, 'db2', 'smooth')\\n\\nfig, ax = plt.subplots(figsize=(12,4))\\nax.plot(chirp_signal, label='signal')\\nax.plot(reconstructed_signal_level1, label='reconstructed level 1', linestyle='--')\\nax.plot(reconstructed_signal_level2, label='reconstructed level 2', linestyle='--')\\nax.plot(reconstructed_signal_level3, label='reconstructed level 3', linestyle='--')\\nax.plot(reconstructed_signal_level4, label='reconstructed level 4', linestyle='--')\\nax.plot(reconstructed_signal_level5, label='reconstructed level 5', linestyle='--')\\nax.legend(loc='upper right')\\nax.set_title('single reconstruction', fontsize=20)\\nax.set_xlabel('time axis', fontsize=16)\\nax.set_ylabel('Amplitude', fontsize=16)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2.Schreibe eine Funktion, die alle Elemente einer Liste, addiert. Es ist verboten mit \\\"sum\\\" zu arbeiten.\\n\",\"targets\":\"lst = [12, 45, 373, 1028]\\n\\ndef addtntor(mylist):\\n    total=0\\n    for elem in mylist:\\n        total+=elem\\n    return total\\n\\naddtntor(lst)\",\"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.2\\/tutorials\\/settings.ipynb\\\".\\nThe first task is:\\ndict_set_all\\ndict_set_all is a BooleanParameter (defaults to False) that controls whether attempting to set a value to a ParameterSet via dictionary access will set all the values in that ParameterSet (if True) or raise an error (if False)\\nCan you write Python code for it?\\n\",\"targets\":\"\\nb['dict_set_all@setting']\\n\\nb['teff@component']\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Define file name for binned data. Note \\\"{}\\\" prepared for string formatting\\nout_bin = '\\/home\\/jovyan\\/DATA\\/HDF5\\/K562_B-bulk.binned_{}.hdf5'\\n\\nres_kb = [100, 20] # Several resolutions in Kb\\n\\nfor res in res_kb:\\n    print(res)\\n    \\n    outmap = out_bin.format(str(res)+'kb') # String formatting\\n\\n    fragments.saveHeatmap(outmap, res*1000) # Save heatmap\\n\\ndel fragments # delete unwanted object\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<a id=\\\"binning\\\"><\\/a>\\n3. Data binning\\nGo top\\nThe previous analysis involved interactions of restriction fragments, now we would like to work with interactions of genomic bins.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"7. Optimizer\\nWe implement the optimizer to perform the updates of the weights according to the certain scheme.\\n\",\"targets\":\"class Optimizer(object):\\n    '''This is a basic class. \\n    All other optimizers will inherit it\\n    '''\\n    def __init__(self, model, lr=0.01, weight_decay=0.0):\\n        self.model = model\\n        self.lr = lr\\n        self.weight_decay = weight_decay\\n        \\n    def update_params(self):\\n        pass\\n\\n\\nclass SGD(Optimizer):\\n    '''Stochastic gradient descent optimizer\\n    https:\\/\\/en.wikipedia.org\\/wiki\\/Stochastic_gradient_descent\\n    '''\\n        \\n    def update_params(self):\\n        weights = self.model.get_params()\\n        grads = self.model.get_params_gradients()\\n        for w, dw in zip(weights, grads):\\n            update = self.lr * dw + self.weight_decay * w\\n            # it writes the result to the previous variable instead of copying\\n            np.subtract(w, update, out=w)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Miscellaneous\\/Gesture-Phase-Detection.ipynb\\\".\\nThe first task is:\\n\\nCan you write Python code for it?\\n\",\"targets\":\"\\npca = PCA(n_components=2)\\nX = pca.fit_transform(X)\\n\\nc = []\\nfrom matplotlib.pyplot import cm \\nn=6\\ncolor=iter(cm.rainbow(np.linspace(0,1,n)))\\nfor i in range(n):\\n    c.append(next(color))\\n\\nn = 5\\nf, (ax1, ax2) = plt.subplots(1, 2, figsize=(8,6))\\n\\nkm = KMeans(n_clusters= n , random_state=0)\\ny_km = km.fit_predict(X)\\n\\nfor i in range(n):\\n    ax1.scatter(X[y_km==i,0], X[y_km==i,1], c=c[i], marker='o', s=40, label='cluster{}'.format(i))\\nax1.set_title('K-means clustering')\\n\\nac = AgglomerativeClustering(n_clusters=n, affinity='euclidean', linkage='complete')\\ny_ac = ac.fit_predict(X)\\nfor i in range(n):\\n    ax2.scatter(X[y_ac==i,0], X[y_ac==i,1], c=c[i], marker='o', s=40, label='cluster{}'.format(i))\\nax2.set_title('Agglomerative clustering')\\n\\n# Put a legend below current axis\\nplt.legend()\\n    \\nplt.tight_layout()\\n#plt.savefig('.\\/figures\\/kmeans_and_ac.png', dpi=300)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Choose Word\\nImplement the pick_word() function to select the next word using probabilities.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef pick_word(probabilities, int_to_vocab):\\n    \\\"\\\"\\\"\\n    Pick the next word in the generated text\\n    :param probabilities: Probabilites of the next word\\n    :param int_to_vocab: Dictionary of word ids as the keys and words as the values\\n    :return: String of the predicted word\\n    \\\"\\\"\\\"\\n\\n    return int_to_vocab[np.random.choice(len(int_to_vocab), None, False, probabilities)]\\n\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_pick_word(pick_word)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# # From pytorch source:\\n# def RNNCell(input, hidden, w_ih, w_hh, b_ih, b_hh):\\n#     return F.tanh(F.linear(input, w_ih, b_ih) + F.linear(hidden, w_hh, b_hh))\\n\\nclass CharSeqStatefulRNN2(nn.Module):\\n    def __init__(self, vocab_size, n_fac, bs):\\n        super().__init__()\\n        self.vocab_size = vocab_size\\n        self.e = nn.Embedding(vocab_size, n_fac)\\n        self.rnn = nn.RNNCell(n_fac, n_hidden)\\n        self.l_out = nn.Linear(n_hidden, vocab_size)\\n        self.init_hidden(bs)\\n        \\n    def forward(self, cs):\\n        bs = cs[0].size(0)\\n        if self.h.size(1) != bs: self.init_hidden(bs)\\n        outp = []\\n        o = self.h\\n        for c in cs:\\n            o = self.rnn(self.e(c), o)\\n            outp.append(o)\\n        outp = self.l_out(torch.stack(outp))\\n        self.h = repackage_var(o)\\n        return F.log_softmax(outp, dim=-1).view(-1, self.vocab_size)\\n    \\n    def init_hidden(self, bs): self.h = V(torch.zeros(1, bs, n_hidden))\\n\\nm = CharSeqStatefulRNN2(mdata.nt, n_fac, 512).cuda()\\nopt = optim.Adam(m.parameters(), 1e-3)\\n\\nfit(m, mdata, 4, opt, F.nll_loss)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n6.3 RNN loop\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Your code here\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow it's your turn. Can you figure out how to load the rest of the data files into datalist automatically?\\nHint: The names of the remaining files are are c2.dat, c3.dat, c4.dat, c5.dat, and c6.dat. What is the only thing that changes among these names? Can you think of a way to generate this part separately and combine it with the rest of the string?\",\"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.3\\/tutorials\\/distribution_propagation.ipynb\\\".\\nThe first task is:\\nBut we can also use parameters to propagate the distributions through the constraints linking parameters together.  For example, since we have distributions on sma and incl, including asini should combine the two distributions according to the constraint and showing the resulting correlations.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n_ = b.plot_distribution_collection(distribution='mydist', \\n                                   parameters=['sma@binary', 'q@binary', 'asini@binary'],\\n                                   show=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 \\\"Generator.ipynb\\\".\\nThe first task is:\\nLever 5: PV system cost adjustment\\nThis lever reflects the role of PV system costs on electrification results. All PV based systems will be adjusted by a factor to simulate a higher or lower cost of PV systems (compared to the baseline values entered below). A value lower than 1 means lower investment costs for PV systems compared to baseline, and a value larger than 1 means higher investment cost for PV systems compared to baseline. E.g. 0.75 would mean a cost that is 25% lower compared to baseline costs.\\nCan you write Python code for it?\\n\",\"targets\":\"\\npv_adjustment_factor = 1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%writefile babyweight\\/trainer\\/model.py\\nimport datetime\\nimport os\\nimport shutil\\nimport numpy as np\\nimport tensorflow as tf\\nimport hypertune\\n\\n# Determine CSV, label, and key columns\\nCSV_COLUMNS = [\\\"weight_pounds\\\",\\n               \\\"is_male\\\",\\n               \\\"mother_age\\\",\\n               \\\"plurality\\\",\\n               \\\"gestation_weeks\\\"]\\nLABEL_COLUMN = \\\"weight_pounds\\\"\\n\\n# Set default values for each CSV column.\\n# Treat is_male and plurality as strings.\\nDEFAULTS = [[0.0], [\\\"null\\\"], [0.0], [\\\"null\\\"], [0.0]]\\n\\n\\ndef features_and_labels(row_data):\\n    \\\"\\\"\\\"Splits features and labels from feature dictionary.\\n\\n    Args:\\n        row_data: Dictionary of CSV column names and tensor values.\\n    Returns:\\n        Dictionary of feature tensors and label tensor.\\n    \\\"\\\"\\\"\\n    label = row_data.pop(LABEL_COLUMN)\\n\\n    return row_data, label  # features, label\\n\\n\\ndef load_dataset(pattern, batch_size=1, mode='eval'):\\n    \\\"\\\"\\\"Loads dataset using the tf.data API from CSV files.\\n\\n    Args:\\n        pattern: str, file pattern to glob into list of files.\\n        batch_size: int, the number of examples per batch.\\n        mode: 'train' | 'eval' to determine if training or evaluating.\\n    Returns:\\n        `Dataset` object.\\n    \\\"\\\"\\\"\\n    print(\\\"mode = {}\\\".format(mode))\\n    # Make a CSV dataset\\n    dataset = tf.data.experimental.make_csv_dataset(\\n        file_pattern=pattern,\\n        batch_size=batch_size,\\n        column_names=CSV_COLUMNS,\\n        column_defaults=DEFAULTS)\\n\\n    # Map dataset to features and label\\n    dataset = dataset.map(map_func=features_and_labels)  # features, label\\n\\n    # Shuffle and repeat for training\\n    if mode == 'train':\\n        dataset = dataset.shuffle(buffer_size=1000).repeat()\\n\\n    # Take advantage of multi-threading; 1=AUTOTUNE\\n    dataset = dataset.prefetch(buffer_size=1)\\n\\n    return dataset\\n\\n\\ndef create_input_layers():\\n    \\\"\\\"\\\"Creates dictionary of input layers for each feature.\\n\\n    Returns:\\n        Dictionary of `tf.Keras.layers.Input` layers for each feature.\\n    \\\"\\\"\\\"\\n    deep_inputs = {\\n        colname:...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nIn the same way we can write to the file model.py the model that we developed in the previous notebooks. \\nCreate trainer module's model.py to hold Keras model code.\\nTo create our model.py, we'll use the code we wrote for the Wide & Deep model. Look back at your 9_keras_wide_and_deep_babyweight notebook and copy\\/paste the necessary code from that notebook into its place in the cell below.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Appendix: Sanity Check Code\\nI wanted to make sure the resizing didn't cause significant distortion for images which werent' square already. The following code helped with this sanity check.\\n\",\"targets\":\"from scipy import misc\\npath = testDataPath + \\\"\\/JayaBhaduri_42.jpg\\\"\\nimg = misc.imread(path)\\nimg = misc.imresize(img, (150, 150))\\n\\nmisc.imsave(\\\"test1000.jpg\\\", img)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"By default, cross_val_score will use StratifiedKFold for classification, which ensures that the class proportions in the dataset are reflected in each fold. If you have a binary classification dataset with 90% of data point belonging to class 0, that would mean that in each fold, 90% of datapoints would belong to class 0.\\nIf you would just use KFold cross-validation, it is likely that you would generate a split that only contains class 0.\\nIt is generally a good idea to use StratifiedKFold whenever you do classification.\\nStratifiedKFold would also remove our need to shuffle iris.\\nLet's see what kinds of folds it generates on the unshuffled iris dataset.\\nEach cross-validation class is a generator of sets of training and test indices:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncv = StratifiedKFold(n_splits=5)\\nfor train, test in cv.split(iris.data, iris.target):\\n    print(test)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<h3>We can drill down into complaints by Agency by borough<\\/h3>\\n\",\"targets\":\"agency_borough = data.groupby(['Agency', 'Borough']).size().unstack()\\n\\nagency_borough\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Nuclear\\/PoissonML.ipynb\\\".\\nThe first task is:\\nand some boundaries for the range of parameters:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nbnds = ((-np.infty,np.infty), (-np.infty,np.infty), (0.1,np.infty), (-10., 10.))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Build Train\\/Test Set\\n\",\"targets\":\"# build label dataframe\\nlabel_df = pd.DataFrame(y.reset_index(drop=True))\\\\\\n    .reset_index()\\nlabel_df.columns = ['example_id', 'label']\\n\\n# split into training and test \\ntrain_id, test_id = train_test_split(label_df.example_id, random_state=43, test_size=0.2)\\ntrain_id = pd.DataFrame(train_id)\\ntest_id  = pd.DataFrame(test_id)\\n\\ndata_train = master_df.merge(train_id, on='example_id')\\ndata_test = master_df.merge(test_id, on='example_id')\\nprint float(data_train.shape[0])\\/(data_train.shape[0] + data_test.shape[0])\\n\\nlabel_train = label_df.merge(train_id, on='example_id')\\nlabel_test = label_df.merge(test_id, on='example_id')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"(IMPLEMENTATION) Train and Validate the Model\\nTrain and validate your model in the code cell below.  Save the final model parameters at filepath 'model_scratch.pt'.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef train(n_epochs, loaders, model, optimizer, criterion, use_cuda, save_path):\\n    \\\"\\\"\\\"returns trained model\\\"\\\"\\\"\\n    # initialize tracker for minimum validation loss\\n    valid_loss_min = np.Inf \\n    \\n    for epoch in range(1, n_epochs+1):\\n        # initialize variables to monitor training and validation loss\\n        train_loss = 0.0\\n        valid_loss = 0.0\\n        \\n        ###################\\n        # train the model #\\n        ###################\\n        model.train()\\n        for batch_idx, (data, target) in enumerate(loaders['train']):\\n            # move to GPU\\n            if use_cuda:\\n                data, target = data.cuda(), target.cuda()\\n            ## find the loss and update the model parameters accordingly\\n            ## record the average training loss, using something like\\n            ## train_loss = train_loss + ((1 \\/ (batch_idx + 1)) * (loss.data - train_loss))\\n            \\n        ######################    \\n        # validate the model #\\n        ######################\\n        model.eval()\\n        for batch_idx, (data, target) in enumerate(loaders['valid']):\\n            # move to GPU\\n            if use_cuda:\\n                data, target = data.cuda(), target.cuda()\\n            ## update the average validation loss\\n\\n            \\n        # print training\\/validation statistics \\n        print('Epoch: {} \\\\tTraining Loss: {:.6f} \\\\tValidation Loss: {:.6f}'.format(\\n            epoch, \\n            train_loss,\\n            valid_loss\\n            ))\\n        \\n        ## TODO: save the model if validation loss has decreased\\n            \\n    # return trained model\\n    return model\\n\\n\\n# train the model\\nmodel_scratch = train(100, loaders_scratch, model_scratch, optimizer_scratch, \\n                      criterion_scratch, use_cuda, 'model_scratch.pt')\\n\\n# load the model that got the best validation accuracy\\nmodel_scratch.load_state_dict(torch.load('model_scratch.pt'))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<!--Empty Space for separating topics-->\\n\\n<h2 id=\\\"Makeup_Data\\\">Make Some Data<\\/h2>\\n\\nSet random seed:\\n\",\"targets\":\"# Set random seed\\n\\ntorch.manual_seed(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 \\\"BlogPosts\\/Decorator_mixing\\/decorator_mixing.ipynb\\\".\\nThe first task is:\\nAha! So the __isabstractmethod__ hasn't disappeared at all! It's just been wrapped by @cachedproperty into the func attribute of the method. But that's not where Python 3 expects it to be. That should be an easy fix.\\nA Fix!\\nCan you write Python code for it?\\n\",\"targets\":\"\\nclass cachedproperty:\\n\\n    def __init__(self, func):\\n        self.__doc__ = getattr(func, '__doc__')\\n        self.__isabstractmethod__ = func.__isabstractmethod__ # The fix!\\n        self.func = func\\n\\n    def __get__(self, obj, objtype=None):\\n        if obj is None:\\n            return self\\n        value = obj.__dict__[self.func.__name__] = self.func(obj)\\n        return value\\n\\n    def __repr__(self):\\n        cn = self.__class__.__name__\\n        return '<%s func=%s>' % (cn, self.func)\\n    \\n    \\nclass AbstractTimeProvider(ABC):\\n    \\n    @cachedproperty\\n    @abstractmethod\\n    def time(self):\\n        pass\\n\\ntry:\\n    AbstractTimeProvider()\\nexcept TypeError as e:\\n    print('TypeError:', e)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Configure model\\n\",\"targets\":\"model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\\n\\nmodelcheckpoint = ModelCheckpoint(filepath=output_dir+\\\"\\/weights.{epoch:02d}.hdf5\\\")\\n\\nif not os.path.exists(output_dir):\\n    os.makedirs(output_dir)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Tuple\\n# Tuples are read-only collections of items.\\na = (1, 2, 3) \\nprint(a)\\n\\n\\n\\n# List\\n# Lists use the square bracket notation and can be index using array notation.\\nmylist = [1, 2, 3] \\nprint(\\\"Zeroth Value: %d\\\" % mylist[0]) \\nmylist.append(4) \\nprint(\\\"List Length: %d\\\" % len(mylist)) \\nfor value in mylist: \\n    print(value)\\n\\n\\n# Dictionary\\n# Dictionaries are mappings of names to values, like key-value pairs. Note the use of the curly bracket and colon notations when defining the dictionary.\\nmydict = {'a': 1, 'b': 2, 'c': 3} \\nprint(\\\"A value: %d\\\" % mydict['a']) \\nmydict['a'] = 11 \\nprint(\\\"A value: %d\\\" % mydict['a']) \\nprint(\\\"Keys: %s\\\" % mydict.keys()) \\nprint(\\\"Values: %s\\\" % mydict.values()) \\nfor key in mydict.keys(): \\n    print(mydict[key])\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nData Structures\\nThere are three data structures in Python that you will find the most used and useful. They are tuples, lists and dictionaries.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Debug blocker output\\ndbg = em.debug_blocker(C1, A, B, output_size=200)\\n\\n# Display first few tuple pairs from the debug_blocker's output\\ndbg.head()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nDebug blocker output\\nThe number of tuple pairs considered for matching is reduced to 10165 (from 176423), but we would want to make sure that the blocker did not drop any potential matches. We could debug the blocker output in py_entitymatching as follows:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<br>\\nCuando tenemos un caso como este es más seguro utilizar los atributos iloc o loc según sea el caso.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ns[0] #Esta instrucción no llamará s.iloc[0] como esperaríamos y va a generar un error\\n\\ns.iloc[0]\\n\\ns.loc[99]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create placeholders\\nx_train_tensor = tf.placeholder(tf.float32, shape=(None, 784))\\nx_test_tensor = tf.placeholder(tf.float32, shape=[784])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nStep 1: Create placeholders to hold the images. \\n\\nUsing None for a dimension in shape means it can be any number.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"01-Intro-to-Computational-Tools-Python.ipynb\\\".\\nThe first task is:\\nLists’ values can be replaced by assigning to specific indices.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ncountry_list[0] = \\\"Iran\\\"\\nprint('Country List is now:', country_list)\",\"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 Analyst Nanodegree Project 1.ipynb\\\".\\nThe first task is:\\nWhat is our independent variable? What is our dependent variable?\\nIndependent variable: the text color condition (congruent or incongruent).\\nDependent variable: the reaction time (the time it takes to name the ink color).\\nWhat is an appropriate set of hypotheses for this task? What kind of statistical test do you expect to perform? Justify your choices.\\nNull hypothesis: the reaction time for the congruent and incongruent conditions is the same.\\n$$\\\\mu(\\\\text{congruent}) = \\\\mu(\\\\text{incongruent})$$\\nAlternative hypothesis: the reaction time for the two conditons are different.\\n$$\\\\mu(\\\\text{congruent})  \\\\neq \\\\mu(\\\\text{incongruent})$$\\nIt's hard to imagine the reverse being true; that the reaction time would be faster for the incongruent condition. On the other hand, it is not a priori completely implausible that the  reaction times would be the same.\\nWe will use the paired t-test to test whether the mean reaction times under the two conditions are equal or not. The t-test allows finding out whether the means of two sets of data are different.\\nWe believe the use of a paired t-test is appropriate since the following conditions are met (see [1], Analysis checklist: Paired t test):\\n1. Are the differences distributed according to a Gaussian distribution?\\nAs will be shown graphically in a later section, the differences are distributed close to normally.\\n2. Was the pairing effective?\\nThe pairing was part of the design of the experiment; each pair represents trials from a single participant. This is an effective pairing method.\\n3. Are the pairs independent?\\nEach pair corresponds to trials by a different participant; they are independent.\\n4. Are you comparing exactly two groups?\\nYes.\\n5. If you chose a one-tail P value, did you predict correctly?\\nWe did not choose a one-tail P value (although we could have).\\n6. Do you care about differences or ratios?\\nWe expect the control values and differences to be of the same order of magnitude, so differences should be fine.\\nReport some descriptive statistics regarding this dataset....\\nCan you write Python code for it?\\n\",\"targets\":\"\\nIQR_congruent = df['Congruent'].quantile(0.75) - df['Congruent'].quantile(0.25)\\nIQR_incongruent = df['Incongruent'].quantile(0.75) - df['Incongruent'].quantile(0.25)\\nprint(df['Congruent'].median(), df['Incongruent'].median(), IQR_congruent, IQR_incongruent)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"FDMS\\/TME2\\/TME2FDMS_Florian_Toque.ipynb\\\".\\nThe first task is:\\nWe observe that, as expected, the more we take L1 into account the less features are used.\\nCan you write Python code for it?\\n\",\"targets\":\"\\neps=0.00001\\nla = []\\ncross_sc = []\\nused_features = []\\n\\nfor lamb in np.arange(0.05,1.05,0.05):\\n    theta = copy.deepcopy(X[0])\\n    gd = ElasticNet(alpha = 0.2, l1_ratio=lamb)\\n    nbIterations = 4000\\n    gd.fit(X,y)\\n    scoresSvm = cross_validation.cross_val_score(gd, X, y, cv=5,scoring=scorer)\\n    print(\\\"Lamda: %s | Cross val mean: %.03f | Features: %d\\\"%(str(lamb).ljust(5),np.mean(scoresSvm),np.count_nonzero(gd.coef_)))\\n    #print(\\\"Lamda: %.02f | Cross val mean: %.02f | Features: %d\\\"%(lamb,gd.score(X,y),gd.used_features))\\n    cross_sc.append(np.mean(scoresSvm))\\n    la.append(lamb)\\n    used_features.append(np.count_nonzero(gd.coef_))\\n\\nfig, ax1 = plt.subplots()\\n\\nax2 = ax1.twinx()\\nax1.plot(la, cross_sc, '#FF9900')\\nax2.plot(la, used_features, '#9933FF')\\n\\nax1.set_xlabel('L1 L2 ratio')\\nax1.set_ylabel('Cross val score', color='#FF9900')\\nax2.set_ylabel('Nb features used', color='#9933FF')\\n\\nax1.yaxis.grid(False)\\nax2.grid(False)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Bounds Testing\\nUECMResults expose the bounds test of Pesaran, Shin, and Smith (2001).  This test facilitates testing whether there is a level relationship between a set of variables without identifying which variables are I(1). This test provides two sets of critical and p-values.  If the test statistic is below the critical value for the lower bound, then there appears to be no levels relationship irrespective of the order or integration in the $X$ variables.  If it is above the upper bound, then there appears to be a levels relationship again, irrespective of the order of integration of the $X$ variables. There are 5 cases covered in the paper that include different combinations of deterministic regressors in the model or the test.\\n$$\\\\Delta Y_{t}=\\\\delta_{0} + \\\\delta_{1}t + Z_{t-1}\\\\beta + \\\\sum_{j=0}^{P}\\\\Delta X_{t-j}\\\\Gamma + \\\\epsilon_{t}$$\\nwhere $Z_{t-1}$ includes both $Y_{t-1}$ and $X_{t-1}$.\\nThe cases determine which deterministic terms are included in the model and which are tested as part of the test.\\n\\nNo deterministic terms\\nConstant included in both the model and the test\\nConstant included in the model but not in the test\\nConstant and trend included in the model, only trend included in the test\\nConstant and trend included in the model, neither included in the test\\n\\nHere we run the test on the Danish money demand data set. Here we see the test statistic is above the 95% critical value for both the lower and upper.\\nPesaran, M. H., Shin, Y., & Smith, R. J. (2001). Bounds testing approaches to the analysis of level relationships. Journal of applied econometrics, 16(3), 289-326.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\necm = UECM(data.lrm, 3, data[[\\\"lry\\\", \\\"ibo\\\", \\\"ide\\\"]], 3, trend=\\\"c\\\")\\necm_fit = ecm.fit()\\nbounds_test = ecm_fit.bounds_test(case=4)\\nbounds_test\\n\\nbounds_test.crit_vals\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Build a trainable blockwise lower-triangular linear operator. We'll apply it to the standard Normal distribution to implement a (trainable) blockwise matrix transformation and induce the correlation structure of the posterior.\\nWithin the blockwise linear operator, a trainable full-matrix block represents full covariance between two components of the posterior, while a block of zeros (or None) expresses independence. Blocks on the diagonal are either lower-triangular or diagonal matrices, so that the entire block structure represents a lower-triangular matrix.\\nApplying this bijector to the base distribution results in a multivariate Normal distribution with mean 0 and (Cholesky-factored) covariance equal to the lower-triangular block matrix.\\n\",\"targets\":\"operators = (\\n    (tf.linalg.LinearOperatorDiag,),  # Variance of uranium weight (scalar).\\n    (tf.linalg.LinearOperatorFullMatrix,  # Covariance between uranium and floor-by-county weights.\\n     tf.linalg.LinearOperatorDiag),  # Variance of floor-by-county weight (scalar).\\n    (None,  # Independence between uranium weight and county effects.\\n     None,  #  Independence between floor-by-county and county effects.\\n     tf.linalg.LinearOperatorDiag)  # Independence among the 85 county effects.\\n    )\\n\\nblock_tril_linop = (\\n    tfp.experimental.vi.util.build_trainable_linear_operator_block(\\n        operators, flat_event_size))\\nscale_bijector = tfb.ScaleMatvecLinearOperatorBlock(block_tril_linop)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# gv returns both gradients and values of original function\\ngrads, value = gv(x)\\n\\nprint('Gradients:')\\nfor g, var_name in zip(grads, module_vars.keys()):\\n    print(g, ' w.r.t. ', var_name)\\nprint()\\nprint('Value: ', value)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\ngv is a module which returns the gradients of loss_fn and the values of loss_fn for the given input:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Activations of Conv 2\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Conv 2\\nf, axes = plt.subplots(2, 4, figsize=(16, 8))\\n\\nfor i in range(2):\\n    for j in range(4):\\n        ax = axes[i, j]\\n        ax.imshow(activations['conv_2'][i, j], cmap=plt.cm.gray_r)\\n        ax.set_xticks([])\\n        ax.set_yticks([])\\n        ax.set_title('Channel {}'.format(j + 1))\\n\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Ajout de contraintes: super(type, obj_ou_type) [TODO]\\nUne autre syntaxe peut être utilisée pour rendre un peut plus explicite la classe de base à utiliser pour l'appel de la fonction:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nclass A:\\n    def bonjour(self):\\n        print(\\\"Bonjour de la part de A.\\\")\\n\\nclass B(A):\\n    def bonjour(self):\\n        print(\\\"Bonjour de la part de B.\\\")\\n\\nclass C(B):\\n    def bonjour(self):\\n        print(\\\"Bonjour de la part de C.\\\")\\n        super(C, self).bonjour()\\n\\nc = C()\\nc.bonjour()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Apply StringIndex to index the entity_id.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nif \\\"id\\\" in documents_entities.columns:\\n    documents_entities = documents_entities.drop(\\\"id\\\")\\n\\ndocuments_entities =  StringIndexer(inputCol=\\\"entity_id\\\", outputCol=\\\"id\\\")\\\\\\n.fit(documents_entities)\\\\\\n.transform(documents_entities)\\n\\ndocuments_entities.show()\\n\\ndocuments_entities_n = documents_entities\\\\\\n.withColumn(\\\"pair\\\", F.struct(\\\"id\\\", \\\"confidence_level\\\"))\\\\\\n.groupBy(\\\"document_id\\\")\\\\\\n.agg(F.collect_list(\\\"pair\\\").alias(\\\"entities\\\"))\\n\\ndocuments_entities_n.printSchema()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Generating_permutations_with_Python.ipynb\\\".\\nThe first task is:\\nHowever, IPython's %timeit function warns us that itertools.permutation could use caching, and that could bias the result.\\nOne easy way to remove any caching is to test on different input lists, and that can be done, for instance, with random lists.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom numpy.random import choice\\n\\ndef random_list_of_size_n(n=5, N=1000):\\n    return list(choice(list(range(1, N + 1)), size=n, replace=False))\\n\\nrandom_list_of_size_n(5)\\n\\n%timeit len(list(itertools_permutations(random_list_of_size_n(5))))\\n%timeit len(list(third_permutations(random_list_of_size_n(5))))\\n\\n%timeit len(list(itertools_permutations(random_list_of_size_n(6))))\\n%timeit len(list(third_permutations(random_list_of_size_n(6))))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#NBVAL_IGNORE_OUTPUT\\nop(time=time_range.num-1, dt=dt)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAnd now execute the operator:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%matplotlib inline\\nimport pandas as pd\\nimport seaborn as sb\\nfrom sklearn.ensemble import RandomForestClassifier\\nfrom sklearn.cross_validation import train_test_split\\nfrom sklearn.cross_validation import cross_val_score\\n\\n# We can jump directly to working with the clean data because we saved our cleaned data set\\niris_data_clean = pd.read_csv('iris-data-clean.csv')\\n\\n# Testing our data: Our analysis will stop here if any of these assertions are wrong\\n\\n# We know that we should only have three classes\\nassert len(iris_data_clean['class'].unique()) == 3\\n\\n# We know that sepal lengths for 'Iris-versicolor' should never be below 2.5 cm\\nassert iris_data_clean.loc[iris_data_clean['class'] == 'Iris-versicolor', 'sepal_length_cm'].min() >= 2.5\\n\\n# We know that our data set should have no missing measurements\\nassert len(iris_data_clean.loc[(iris_data_clean['sepal_length_cm'].isnull()) |\\n                               (iris_data_clean['sepal_width_cm'].isnull()) |\\n                               (iris_data_clean['petal_length_cm'].isnull()) |\\n                               (iris_data_clean['petal_width_cm'].isnull())]) == 0\\n\\nall_inputs = iris_data_clean[['sepal_length_cm', 'sepal_width_cm',\\n                             'petal_length_cm', 'petal_width_cm']].values\\n\\nall_classes = iris_data_clean['class'].values\\n\\n# This is the classifier that came out of Grid Search\\nrandom_forest_classifier = RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\\n                                max_depth=None, max_features=3, max_leaf_nodes=None,\\n                                min_samples_leaf=1, min_samples_split=2,\\n                                min_weight_fraction_leaf=0.0, n_estimators=5, n_jobs=1,\\n                                oob_score=False, random_state=None, verbose=0, warm_start=True)\\n\\n# All that's left to do now is plot the cross-validation scores\\nrf_classifier_scores = cross_val_score(random_forest_classifier, all_inputs, all_classes, cv=10)\\nsb.boxplot(rf_classifier_scores)\\nsb.stripplot(rf_classifier_scores,...\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFinally, let's extract the core of our work from Steps 1-5 and turn it into a single pipeline.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Answer: \\n\\nThe optimal max_depth for my model is 6, which is close to the expectation that max_depth = 5. The difference may be caused by setting max_features=sqrt as a result of GridSearchCV. \\n\\nQuestion 11\\nWith your parameter-tuned model, what is the best selling price for your client's home? How does this selling price compare to the basic statistics you calculated on the dataset?  \\nHint:  Run the code block below to have your parameter-tuned model make a prediction on the client's home.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsale_price = reg.predict(CLIENT_FEATURES)\\nprint \\\"Predicted value of client's home: {0:.3f}\\\".format(sale_price[0])\\nprint(\\\"Compared to mean: %.3f\\\\nCompared to median: %.3f\\\\nStd of boston housing price data: %.3f\\\" \\n      % ((sale_price[0]-mean_price)\\/mean_price,\\n         (sale_price[0]-median_price)\\/median_price,\\n          std_dev))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<span id=\\\"slip_plat_prod\\\">Choose Platform and Product &#9652;<\\/span>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nplatform = 'LANDSAT_8'\\nproduct = 'ls8_usgs_sr_scene'\\ncollection = 'c1'\\nlevel = 'l2'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"3_Plotting_Categorical_Data.ipynb\\\".\\nThe first task is:\\nYou can see that though the category 'Technology' has better sales numbers than others, it is also the one where the most loss making transactions happen. You can drill further down into this.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# adjust figure size\\nplt.figure(figsize=(10, 8))\\n\\n# subplot 1: Sales\\nplt.subplot(1, 2, 1)\\nsns.boxplot(x='Product_Category', y='Sales', data=df)\\nplt.title(\\\"Sales\\\")\\nplt.yscale('log')\\n\\n# subplot 2: Profit\\nplt.subplot(1, 2, 2)\\nsns.boxplot(x='Product_Category', y='Profit', data=df)\\nplt.title(\\\"Profit\\\")\\n\\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 \\\"2.3\\/examples\\/extinction_wd_subdwarf.ipynb\\\".\\nThe first task is:\\nAs always, let's do imports and initialize a logger and a new bundle.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport matplotlib\\nmatplotlib.rcParams['text.usetex'] = True\\nmatplotlib.rcParams['pdf.fonttype'] = 42\\nmatplotlib.rcParams['ps.fonttype'] = 42\\nmatplotlib.rcParams['mathtext.fontset'] = 'stix'\\nmatplotlib.rcParams['font.family'] = 'STIXGeneral'\\nfrom matplotlib import gridspec\\n\\n%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\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Python for Data Analysis.ipynb\\\".\\nThe first task is:\\nSorting and ranking\\nCan you write Python code for it?\\n\",\"targets\":\"\\nobj = Series(range(4), index=['d', 'a', 'b', 'c'])\\n\\nobj\\n\\nobj.sort_index()\\n\\nframe = DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})\\n\\nframe.sort_values('b')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"(1e) Aplicar OHE em uma base de dados \\nFinalmente, use a função da parte (1d) para criar atributos OHE para todos os 3 objetos da base de dados artificial.\\n\",\"targets\":\"# EXERCICIO\\nsampleOHEData = sampleDataRDD.map(lambda x:oneHotEncoding(x, sampleOHEDictManual, numSampleOHEFeats))#<COMPLETAR>\\nprint sampleOHEData.collect()\\n\\n# TEST Apply OHE to a dataset (1e)\\nsampleOHEDataValues = sampleOHEData.collect()\\nTest.assertTrue(len(sampleOHEDataValues) == 3, 'sampleOHEData should have three elements')\\nTest.assertEquals(sampleOHEDataValues[0], SparseVector(7, {2: 1.0, 3: 1.0}),\\n                  'incorrect OHE for first sample')\\nTest.assertEquals(sampleOHEDataValues[1], SparseVector(7, {1: 1.0, 4: 1.0, 5: 1.0}),\\n                  'incorrect OHE for second sample')\\nTest.assertEquals(sampleOHEDataValues[2], SparseVector(7, {0: 1.0, 3: 1.0, 6: 1.0}),\\n                  'incorrect OHE for third sample')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%octave_pull tempin ALK DIC pH pCO2 fCO2 xCO2 HCO3 CO3 CO2 RF OmegaAr\\n\\n#print(tempin)\\npieces = [ALK, DIC, pH, pCO2, fCO2, xCO2, HCO3, CO3, CO2, RF, OmegaAr]\\npieces = np.array(pieces)\\npieces = np.squeeze(pieces)\\npieces = np.transpose(pieces)\\ncols = list(['ALK', 'DIC', 'pH', 'pCO2', 'fCO2', 'xCO2', 'HCO3', 'CO3', 'CO2', 'RF', 'OmegaAr'])\\n#pad = pd.DataFrame(pieces, index=list(tempin), columns=cols)\\ndf = pd.DataFrame(pieces, columns=cols)\\ndf\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n5. Pull arrays (from octave to python), then use pandas to display a nice table\\nPull arrays, then combine into a pandas DataFrame\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# При каждом вызове функции fib создаётся локальная область видимости с переменными n, a, b и i\\ndef fib(n):\\n    a, b = 0, 1\\n    for i in range(n):\\n        a, b = b, a + b\\n    return a\\n\\n# Глобальная область видимости содержит переменную k\\nk = int(input())\\nprint(fib(k))\\n\\n# При отсутствии переменной в локальной области видимости, используется такая же переменная из глобальной\\ndef f(a):\\n    return a + b\\n\\nb = 4\\nprint(f(7))\\n\\n# Ошибка. Локальная переменная неизвестна после окончания функции \\ndef f():\\n    local_var = \\\"Only local\\\"\\n    print(local_var)\\n\\nf()\\nprint(local_var)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nОбласти видимости\\nОбласть видимости — это изолированная часть программы со своим набором переменных.\\nВсе переменные, объявленные в основной программе находятся в глобальной области видимости.\\nПри каждом вызове функции создаётся новая локальная область видимости.\",\"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-loops-control-flow.ipynb\\\".\\nThe first task is:\\nBut it might be that the input is just wrong: there's a typo, and the caller should be warned, and maybe the input completely rejected. We can write a different function to check that.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom math import pi\\n\\ndef check_angle_normalized(theta_d):\\n    \\\"\\\"\\\"\\n    Check that an angle lies within [0, 360] degrees.\\n    \\n    Parameters\\n    ----------\\n    \\n    theta_d : float\\n        The angle in degrees.\\n        \\n    Returns\\n    -------\\n    \\n    normalized : Boolean\\n        Whether the angle lies within the range\\n    \\\"\\\"\\\"\\n    \\n    normalized = True\\n    if theta_d > 360.0:\\n        normalized = False\\n        print(\\\"Input angle greater than 360 degrees. Did you mean this?\\\")\\n    if theta_d < 0.0:\\n        normalized = False\\n        print(\\\"Input angle less than 0 degrees. Did you mean this?\\\")\\n    return normalized\\n\\ntheta_d = 5134.6\\nprint(check_angle_normalized(theta_d))\\ntheta_d = -52.3\\nprint(check_angle_normalized(theta_d))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create schema file\\nThe deployment requires a schema file to define the incoming data.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# We'll use the known label, key variables and \\n# a few extra columns we won't need. (machineID is required)\\nkey_cols =['label_e','dt_truncated', 'failure','model_encoded','model' ]\\n\\n# Then get the remaining feature names from the data\\ninput_features = fedata.columns\\n# Remove the extra stuff if it's in the input_df\\ninput_features = [x for x in input_features if x not in set(key_cols)]\\n\\n# define the input data frame\\ninputs = {\\\"input_df\\\": SampleDefinition(DataTypes.SPARK, \\n                                       fedata.select(input_features))}\\n\\njson_schema = generate_schema(run_func=run, inputs=inputs, filepath='service_schema.json')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%time\\n#     generate 8000 pairs\\npairs = []\\nfor i in range(8000):\\n    pairs.append(pcPairGenRand())\\n#     lin attack\\npartialKey = linearAttack(pairs)\\n\\n%%time\\ndef bruteForce(partialKey=partialKey, pairs=pairs):\\n    print(\\\"start brute force\\\")\\n    for bits20 in range(2 ** 20):\\n        for bits4 in range(2 ** 4):\\n            primitiveKeyLocal = \\\\\\n            (bits20 << 12)| (partialKey[0] << 8) \\\\\\n            | (bits4 << 4)|(partialKey[1] << 0)\\n            Kl = {}\\n            Kl[1] = (primitiveKey >> 16) & 0xFFFF\\n            Kl[2] = (primitiveKey >> 12) & 0xFFFF\\n            Kl[3] = (primitiveKey >> 8) & 0xFFFF\\n            Kl[4] = (primitiveKey >> 4) & 0xFFFF\\n            Kl[5] = primitiveKey & 0xFFFF\\n            neq = False\\n            paircount = len(pairs)\\n            for index in range(paircount):\\n                (plain, cipher) = pairs[index]\\n                if spnFromTextEncryption\\\\\\n                (x=plain, K=Kl) != cipher:\\n                    break\\n                elif index == paircount:\\n                    print(primitiveKeyLocal)\\n    print(\\\"\\\"\\\"done\\\"\\\"\\\")\\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\":\"Also plot the zonally averaged insolation at a few different times of the year:\\n\",\"targets\":\"summer_solstice = 170\\nwinter_solstice = 353\\nfig, ax = plt.subplots(figsize=(10,8))\\nax.plot( lat, Q[:,(summer_solstice, winter_solstice)] );\\nax.plot( lat, np.mean(Q, axis=1), linewidth=2 )\\nax.set_xbound(-90, 90)\\nax.set_xticks( range(-90,100,30) )\\nax.set_xlabel('Latitude', fontsize=16 );\\nax.set_ylabel('Insolation (W m$^{-2}$)', fontsize=16 );\\nax.grid()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"0.13\\/_downloads\\/plot_background_filtering.ipynb\\\".\\nThe first task is:\\nThis filter hypothetically achieves zero ripple in the frequency domain,\\nperfect attenuation, and perfect steepness. However, due to the discontunity\\nin the frequency response, the filter would require infinite ringing in the\\ntime domain (i.e., infinite order) to be realized. Another way to think of\\nthis is that a rectangular window in frequency is actually sinc_ function\\nin time, which requires an infinite number of samples, and thus infinite\\ntime, to represent. So although this filter has ideal frequency suppression,\\nit has poor time-domain characteristics.\\nLet's try to naïvely make a brick-wall filter of length 0.1 sec, and look\\nat the filter itself in the time domain and the frequency domain:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nn = int(round(0.1 * sfreq)) + 1\\nt = np.arange(-n \\/\\/ 2, n \\/\\/ 2) \\/ sfreq  # center our sinc\\nh = np.sinc(2 * f_p * t) \\/ (4 * np.pi)\\n\\n\\ndef plot_filter(h, title, freq, gain, show=True):\\n    if h.ndim == 2:  # second-order sections\\n        sos = h\\n        n = mne.filter.estimate_ringing_samples(sos)\\n        h = np.zeros(n)\\n        h[0] = 1\\n        h = signal.sosfilt(sos, h)\\n        H = np.ones(512, np.complex128)\\n        for section in sos:\\n            f, this_H = signal.freqz(section[:3], section[3:])\\n            H *= this_H\\n    else:\\n        f, H = signal.freqz(h)\\n    fig, axs = plt.subplots(2)\\n    t = np.arange(len(h)) \\/ sfreq\\n    axs[0].plot(t, h, color=blue)\\n    axs[0].set(xlim=t[[0, -1]], xlabel='Time (sec)',\\n               ylabel='Amplitude h(n)', title=title)\\n    box_off(axs[0])\\n    f *= sfreq \\/ (2 * np.pi)\\n    axs[1].semilogx(f, 10 * np.log10((H * H.conj()).real), color=blue,\\n                    linewidth=2, zorder=4)\\n    plot_ideal(freq, gain, axs[1])\\n    mne.viz.tight_layout()\\n    if show:\\n        plt.show()\\n\\nplot_filter(h, 'Sinc (0.1 sec)', freq, gain)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<b>Create the figure and set up plotting instances.<br><br>\\nCreate basemaps to use for the horizontal plots.<br><br>\\nExecute the plotting routines.<\\/b>\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 12))#, sharex='col', sharey='row')\\n\\nbm1 = create_basemap(corners=corners, proj=proj, resolution='l', area_thresh=1., \\n                  lat_spacing=dLat, lon_spacing=dLon, ax=ax1)\\nbm2 = create_basemap(corners=corners, proj=proj, resolution='l', area_thresh=1., \\n                  lat_spacing=dLat, lon_spacing=dLon, ax=ax2)\\nbm3 = create_basemap(corners=corners, proj=proj, resolution='l', area_thresh=1., \\n                  lat_spacing=dLat, lon_spacing=dLon, ax=ax3)\\nbm4 = create_basemap(corners=corners, proj=proj, resolution='l', area_thresh=1., \\n                  lat_spacing=dLat, lon_spacing=dLon, ax=ax4)\\n\\n# Create a RadarGrid\\nrgp1 = RadarHorizontalPlot(r1, basemap=bm1)\\nrgp2 = RadarHorizontalPlot(r2, basemap=bm2)\\nrgp3 = RadarHorizontalPlot(r3, basemap=bm3)\\nrgp4 = RadarHorizontalPlot(r4, basemap=bm4)\\n\\n# Create a Flightlevel instance for the track\\nflp1 = FlightLevel(fl1, basemap=bm1)\\nflp2 = FlightLevel(fl2, basemap=bm2)\\nflp3 = FlightLevel(fl3, basemap=bm3)\\nflp4 = FlightLevel(fl4, basemap=bm4)\\n\\nrgp1.plot_cappi('reflectivity', 2., vmin=15., vmax=60., title=' ',\\n              color_bar=True, cb_pad=\\\"10%\\\", cb_loc='bottom', cb_tick_int=4,\\n              ax=ax1)\\nrgp2.plot_cappi('Wwind', 2., vmin=-5., vmax=5., title=' ',\\n              mask_procedure='inside', mask_tuple=('Wwind', -1., 1.),\\n              cmap='RdBu_r',\\n              color_bar=True, cb_pad=\\\"10%\\\", cb_loc='bottom', \\n              ax=ax2)\\nrgp3.plot_cappi('reflectivity', 5., vmin=15., vmax=60., title=' ',\\n              color_bar=True, cb_pad=\\\"10%\\\", cb_loc='bottom', cb_tick_int=4,\\n              ax=ax3)\\nrgp4.plot_cappi('Wwind', 5., vmin=-5., vmax=5., title=' ',\\n              mask_procedure='inside', mask_tuple=('Wwind', -1., 1.),\\n              cmap='RdBu_r',\\n              color_bar=True, cb_pad=\\\"10%\\\", cb_loc='bottom', \\n              ax=ax4)\\n\\nflp1.plot_trackmap(\\n              start_time=start_time, end_time=end_time,\\n#             color_by_altitude=True, track_cmap='spectral',\\n#             ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"PyConFr2017.ipynb\\\".\\nThe first task is:\\nimport typeguard\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom typeguard import typechecked\\n\\ndef aff(x: int) -> int:\\n    return x * 2 + 1\\n\\naff(2)\\n\\naff(\\\"2\\\")\\n\\ntaff = typechecked(aff)\\n\\ntaff(2)\\n\\ntaff(\\\"2\\\")\\n\\ntaff(2.)\\n\\nfrom numbers import Number  # PEP 3141\\n@typechecked\\ndef taff(x: Number) -> Number:\\n    return x * 2 + 1\\n\\ntaff(1), taff(1.), taff(1j)\\n\\nprint(\\\"** without type checking **\\\")\\n%timeit aff(2)\\nprint(\\\"** with type checking **\\\")\\n%timeit taff(2)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Aki-Richards: 179 chars\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef a(α,β,ρ,χ,ψ,ω,t):import numpy as n;w=ω-ρ;x=ω+ρ;y=ψ+β;p=n.pi*t\\/180;s=n.sin(p);return w\\/x-(y\\/α)**2*w\\/x*s**2+(χ-α)\\/(χ+α)\\/n.cos((p+n.arcsin(χ\\/α*s))\\/2)**2-(y\\/α)**2*(2*(ψ-β)\\/y)*s**2\\n\\nfrom bruges.reflection import akirichards\\n\\n# 4-term Aki-Richards equation in 255 characters!\\n# http:\\/\\/subsurfwiki.org\\/wiki\\/Aki–Richards_equation\\nimport numpy as np\\nimport matplotlib.pyplot as plt\\n%matplotlib inline\\n\\nrock1 = (2300, 1200, 2500)  # Vp, Vs, rho for layer 1\\nrock2 = (2400, 1250, 2450)  # Vp, Vs, rho for layer 2\\ntheta1 = np.arange(40)\\n\\nresult = a(*rock1, *rock2, theta1)\\n\\nplt.figure(figsize=(10,4))\\nplt.plot(akirichards(*rock1, *rock2, theta1), 'o')\\nplt.plot(result)\\n\\nplt.show()\\n\\ninspect.getsource(a).strip()\\n\\nlen(inspect.getsource(a).strip())\\n\\nlen(inspect.getsource(akirichards).strip())\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# average concentration of B+ is the same as the concentration of A-\\nav_c_Bplus = av_alpha*c_acid\\nerr_c_Bplus = err_alpha*c_acid  # error in the average concentration\\n\\nfull_pH_range = np.linspace(2, 12, 100)\\nideal_c_Aminus = ideal_alpha(full_pH_range, pK)*c_acid\\nideal_c_OH = np.power(10.0, -(pKw - full_pH_range))*ureg('mol\\/L')\\nideal_c_H = np.power(10.0, -full_pH_range)*ureg('mol\\/L')\\n# ideal_c_M is calculated from electroneutrality\\nideal_c_M = np.maximum((ideal_c_Aminus + ideal_c_OH - ideal_c_H).to(\\n    'mol\\/L').magnitude, np.zeros_like(full_pH_range))*ureg('mol\\/L')\\n\\n# plot the simulation results compared with the ideal results of the cations\\nplt.figure(figsize=(10, 6), dpi=80)\\nplt.errorbar(pHs,\\n             av_c_Bplus.to('mol\\/L').magnitude,\\n             err_c_Bplus.to('mol\\/L').magnitude,\\n             marker='o', c=\\\"tab:blue\\\", linestyle='none',\\n             label=r\\\"measured $c_{\\\\mathrm{B^+}}$\\\", zorder=2)\\nplt.plot(full_pH_range, ideal_c_H.to('mol\\/L').magnitude, c=\\\"tab:green\\\",\\n         label=r\\\"ideal $c_{\\\\mathrm{H^+}}$\\\", zorder=0)\\nplt.plot(full_pH_range, ideal_c_M.to('mol\\/L').magnitude, c=\\\"tab:orange\\\",\\n         label=r\\\"ideal $c_{\\\\mathrm{M^+}}$\\\", zorder=0)\\nplt.plot(full_pH_range, ideal_c_Aminus.to('mol\\/L').magnitude, c=\\\"tab:blue\\\", ls=(0, (5, 5)),\\n         label=r\\\"ideal $c_{\\\\mathrm{A^-}}$\\\", zorder=1)\\nplt.yscale(\\\"log\\\")\\nplt.ylim(1e-6,)\\nplt.xlabel('input pH', fontsize=16)\\nplt.ylabel(r'concentration $c$ $[\\\\mathrm{mol\\/L}]$', fontsize=16)\\nplt.legend(fontsize=16)\\nplt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe Neutralizing Ion $\\\\mathrm{B^+}$\\nUp to now we did not discuss the chemical nature the neutralizer $\\\\mathrm{B^+}$. The added salt is not relevant in this context, therefore we omit it from the discussion. The simplest case to consider is what happens if you add the acidic polymer to pure water ($\\\\mathrm{pH} = 7$). Some of the acid groups dissociate and release $\\\\mathrm{H^+}$ ions into the solution. The pH decreases to a value that depends on $\\\\mathrm{p}K_{\\\\mathrm{A}}$ and on the concentration of ionizable groups. Now, three ionic species are present in the solution: $\\\\mathrm{H^+}$, $\\\\mathrm{A^-}$, and $\\\\mathrm{OH^-}$. Because the reaction generates only one $\\\\mathrm{B^+}$ ion in the simulation box, we conclude that in this case the $\\\\mathrm{B^+}$ ions correspond to $\\\\mathrm{H^+}$ ions. The $\\\\mathrm{H^+}$ ions neutralize both the $\\\\mathrm{A^-}$ and the $\\\\mathrm{OH^-}$ ions. At acidic pH there are only very few $\\\\mathrm{OH^-}$ ions and nearly all $\\\\mathrm{H^+}$ ions act as a neutralizer for the $\\\\mathrm{A^-}$ ions. Therefore, the concentration of $\\\\mathrm{B^+}$ is very close to the concentration of $\\\\mathrm{H^+}$ in the real aqueous solution. Only very few $\\\\mathrm{OH^-}$ ions, and the $\\\\mathrm{H^+}$ ions needed to neutralize them, are missing in the simulation box, when compared to the real solution.\\nTo achieve a more acidic pH (with the same pK and polymer concentration), we need to add an acid to the system. We can do that by adding a strong acid, such as HCl or $\\\\mathrm{HNO}_3$. We will denote this acid by a generic name $\\\\mathrm{HX}$ to emphasize that in general its anion can be different from the salt anion $\\\\mathrm{Cl^{-}}$. Now, there are 4 ionic species in the solution:  $\\\\mathrm{H^+}$, $\\\\mathrm{A^-}$, $\\\\mathrm{OH^-}$, and $\\\\mathrm{X^-}$ ions. By the same argument as before, we conclude that $\\\\mathrm{B^+}$ ions correspond to $\\\\mathrm{H^+}$ ions. The $\\\\mathrm{H^+}$ ions neutralize the $\\\\mathrm{A^-}$, $\\\\mathrm{OH^-}$, and the $\\\\mathrm{X^-}$ ions. Because the concentration of $\\\\mathrm{X^-}$ is not...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2.9 Associative Search (Contextual Bandits)\\n\\nnonassociative task: stationary task. 没有场景\\nassociative task: the goal is to learn a policy: a mapping from situations to the actions that are best in those situations. 有场景的区分\\nfull reinforcement learning problem: action are allowed to effec the next situation as well as the reward. 行为可以影响场景。\\n\\nExercise 2.10:\\n\\ncannot tell which case: 0.5 (random)\\ncan tell: A - 2, B - 1: 0.55\\n\\n2.10 Summary\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nImage('res\\/fig2_6.png')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Augment features\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# ## Feature augmentation\\n# Our guess is that facies do not abrutly change from a given depth layer to the next one. Therefore, we consider features at neighboring layers to be somehow correlated. To possibly exploit this fact, let us perform feature augmentation by:\\n# - Select features to augment.\\n# - Aggregating aug_features at neighboring depths.\\n# - Computing aug_features spatial gradient.\\n# - Computing aug_features spatial gradient of gradient.\\n\\n\\n# Feature windows concatenation function\\ndef augment_features_window(X, N_neig, features=-1):\\n    \\n    # Parameters\\n    N_row = X.shape[0]\\n    if features==-1:\\n        N_feat = X.shape[1]\\n        features=np.arange(0,X.shape[1])\\n    else:\\n        N_feat = len(features)\\n\\n    # Zero padding\\n    X = np.vstack((np.zeros((N_neig, X.shape[1])), X, (np.zeros((N_neig, X.shape[1])))))\\n\\n    # Loop over windows\\n    X_aug = np.zeros((N_row, N_feat*(2*N_neig)+X.shape[1]))\\n    for r in np.arange(N_row)+N_neig:\\n        this_row = []\\n        for c in np.arange(-N_neig,N_neig+1):\\n            if (c==0):\\n                this_row = np.hstack((this_row, X[r+c,:]))\\n            else:\\n                this_row = np.hstack((this_row, X[r+c,features]))\\n        X_aug[r-N_neig] = this_row\\n\\n    return X_aug\\n\\n\\n# Feature gradient computation function\\ndef augment_features_gradient(X, depth, features=-1):\\n    \\n    if features==-1:\\n        features=np.arange(0,X.shape[1])\\n    # Compute features gradient\\n    d_diff = np.diff(depth).reshape((-1, 1))\\n    d_diff[d_diff==0] = 0.001\\n    X_diff = np.diff(X[:,features], axis=0)\\n    X_grad = X_diff \\/ d_diff\\n        \\n    # Compensate for last missing value\\n    X_grad = np.concatenate((X_grad, np.zeros((1, X_grad.shape[1]))))\\n    \\n    return X_grad\\n\\n\\n\\n# Feature augmentation function\\ndef augment_features(X, well, depth, N_neig=1, features=-1):\\n    \\n    if (features==-1):\\n        N_Feat=X.shape[1]\\n    else:\\n        N_Feat=len(features)\\n    # Augment features\\n    X_aug = np.zeros((X.shape[0], X.shape[1] + N_Feat*(N_neig*2+2)))\\n    for w in np.unique(well):\\n   ...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Run the solver\\nsolver.solve()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFinally, we run the solver.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"## not all processes have connections, this one does\\njava_conns = conns[conns.Pid=='3156']\\njava_conns['Remote Address'].sort_index().value_counts().plot(kind='bar')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nWe can see that IE was talking to several Internet addresses on web service ports and one local (RFC1918) address on 1337. And Java?\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create an Azure File Share\\nCreate an Azure File Share bucket to store our models and other results.\\nRun the following in your local Bash terminal with Azure CLI or in the Azure Cloud Shell\\n```bash\\nexport AZ_STORAGE_ACCOUNT_NAME=\\\"<your-storage-account-name>\\\"\\nexport AZ_STORAGE_RESOURCE_GROUP=\\\"<your-storage-account-resource-group>\\\"\\nexport AZ_SHARE_NAME=\\\"mnist\\\"\\nSTORAGE_KEY=$(az storage account keys list --resource-group $AZ_STORAGE_RESOURCE_GROUP --account-name $AZ_STORAGE_ACCOUNT_NAME --query \\\"[0].value\\\" -o tsv)\\naz storage share create --name $AZ_SHARE_NAME --account-name $AZ_STORAGE_ACCOUNT_NAME --account-key $STORAGE_KEY\\necho $STORAGE_KEY\\n```\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Insert the Storage Key in the command below to save the storage access credentials as a Kubernetes secret\\n%env STORAGE_KEY='<your-storage-account-access-key>'\\n\\n!kubectl create secret generic azure-share-secret --namespace $TARGET_NAMESPACE --from-literal=azurestorageaccountname=$AZ_STORAGE_ACCOUNT_NAME --from-literal=azurestorageaccountkey=$STORAGE_KEY\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"(a)\\nPrvo, isprobajte ugrađeni model na linearno odvojivom skupu podataka seven ($N=7$).\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nseven_X = np.array([[2,1], [2,3], [1,2], [3,2], [5,2], [5,4], [6,3]])\\nseven_y = np.array([1, 1, 1, 1, 0, 0, 0])\\n\\n# Vaš kôd ovdje\\nrc = RidgeClassifier()\\nrc.fit(seven_X, seven_y)\\n\\nprint(accuracy_score(seven_y, rc.predict(seven_X)))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"2015-10_Lecture\\/Lecture2\\/code\\/1_Intro_Theano.ipynb\\\".\\nThe first task is:\\nThe graph fo z:\\n<img src=\\\"files\\/pics\\/z_graph.png\\\">\\nThe graph for f:\\n<img src=\\\"files\\/pics\\/f_graph.png\\\">\\nSimple matrix multiplications\\nThe following types for input variables are typically used:\\nbyte: bscalar, bvector, bmatrix, btensor3, btensor4\\n16-bit integers: wscalar, wvector, wmatrix, wtensor3, wtensor4\\n32-bit integers: iscalar, ivector, imatrix, itensor3, itensor4\\n64-bit integers: lscalar, lvector, lmatrix, ltensor3, ltensor4\\nfloat: fscalar, fvector, fmatrix, ftensor3, ftensor4\\ndouble: dscalar, dvector, dmatrix, dtensor3, dtensor4\\ncomplex: cscalar, cvector, cmatrix, ctensor3, ctensor4\\n\\nscalar: One element (one number)\\nvector: 1-dimension\\nmatrix: 2-dimensions\\ntensor3: 3-dimensions\\ntensor4: 4-dimensions\\nAs we do not need perfect precision we use mainly float instead of double. Most GPUs are also not able to handle doubles.\\nSo in practice you need: iscalar, ivector, imatrix and fscalar, fvector, vmatrix.\\nTask: Implement the function $$f(x,W,b) = \\\\tanh(xW+b)$$ with $x \\\\in \\\\mathbb{R}^n, b \\\\in \\\\mathbb{R}^k, W \\\\in \\\\mathbb{R}^{n \\\\times k}$.\\n$n$ input dimension and $k$ output dimension\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport theano\\nimport theano.tensor as T\\nimport numpy as np\\n\\n# Put your code here\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Bag of Words (BoW) language model\\nToday we'll see our first, admittedly primitive, computational model of language called \\\"Bag of Words\\\". This model was very popular in early text analysis, and continues to be used today. In fact, the models that have replaced it are still very difficult to actually interpret, giving the BoW approach a slight advantage if we want to understand why the model makes certain decisions.\\nGetting into the model we'll have to revisit Term Frequency (think Counter). We'll then see the Document-Term Matrix (DTM), which we've discusssed briefly before. We'll have to normalize these counts if we want to compare. Then we'll look at the available Python libraries to streamline this process.\\nOnce we have our BoW model we can analyze it in a high-dimensional vector space, which gives us more insights into the similarities and clustering of different texts. We'll then get into Piper's analysis.\\nWe'll build our model  from scratch with numpy and datascience libraries before we get into the higher level libraries:\\n\",\"targets\":\"%matplotlib inline\\nimport numpy as np\\nfrom datascience import *\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Creación de nuevas columnas\\n\",\"targets\":\"# Agruparemos por año y día: creemos dos columnas nuevas\\ndata['year'] = data.index.year\\ndata['month'] = data.index.month\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"After cleaning the data we finished with four dataframes: Rent, Rent_Private, Crime and Crime_Total. We will use these three to produce visual aids to better understand how they relate.\\n3. Visualizing the Data\\n3.1 Housing Data\\nIn here we will just look into the housing data, and see how different are the prices in the different boroughs and different neighborhoods of Manhattan\\n\",\"targets\":\"# Import seaborn package\\n\\nimport seaborn as sns\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Changes:\\n\\nexplicit check for input shape\\nno views and simple sequential structure, output is just nn.Sequential, so can always be saved\\/passed\\/etc\\nno need in AvgPool and additional views, this place is much clearer now\\nmake_layer doesn't use internal state (that's quite faulty place)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom torchvision.models.resnet import BasicBlock, Bottleneck, ResNet\\n\\nx = torch.randn(2, 3, 224, 224)\\nwith torch.no_grad():\\n    model_old = ResNetOld(BasicBlock, layers=[2, 2, 2, 3])\\n    model_new = ResNetNew(BasicBlock, layers=[2, 2, 2, 3])\\n    initialize(model_old)\\n    initialize(model_new)\\n    assert torch.allclose(model_old(x), model_new(x), atol=1e-3)\\n\\n# with torch.no_grad():\\n#     x = torch.randn([2, 512, 7, 7])\\n#     torch.allclose(nn.AvgPool2d(7)(x), reduce(x, 'b c h w -> b c', 'mean'), atol=1e-8)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"20151120-loggins-data\\/20151120-loggins-data.ipynb\\\".\\nThe first task is:\\nAnd now a fact table:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n%%sql\\nDROP TABLE IF EXISTS f_entrance;\\nCREATE TABLE f_entrance (\\n  entrance_id SERIAL PRIMARY KEY,\\n  day_key SMALLINT NOT NULL,\\n  hour SMALLINT NOT NULL,\\n  affiliation VARCHAR(255),\\n  subaffiliation VARCHAR(255),\\n  count INT NOT NULL\\n)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Cómo acelerar tu código Python con numba.ipynb\\\".\\nThe first task is:\\nCreamos nuestro array de datos:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndata = np.random.randn(2000, 2000)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Introductory statistical data analysis with pandas PyData Berlin 2017.ipynb\\\".\\nThe first task is:\\nthe relationship between chest pain and the diagnosis holds for both levels of the sex variables, hence it is not a \\nmoderator.\\nwe would test for moderator variables in the case of a quantitative response variable the same way:\\n1. divide the population into the sublevels of the third variables\\n2. conduct an smf.ols test for each to see if the relationship is statistically significant for each level\\nidentifying a confounding variable does not allow to establish causation, just to get closer to a causal connection.\\ndue to infinite number of possible lurking variables, observational studies cannot rly establish causation\\na lurking of confounding variable is a third variable that is associated with both the explanatory and response \\nvariables.\\ni.e. x=firefighters; y=damage caused by a fire. plot would suggest more firefighters causes more fire damage.\\nin reality there is a third confounding variable that influences both, seriousness of the fire.\\nIn a study we want to demonstrate that our statistical relationship is valid even after controlling for confounders.\\nnow we will test whether there is a relationship between two quantitative variables, age and cholesterol\\nfor this we use the pearson correlation test\\nr, going from -1 to 1 only tells us whether the two variables are linearly related. they may be related in nonlinear ways\\ntherefore it's always important to look at r in parallel with a scatterplot of the two variables\\nr squared is a measure of how much variability in one variable can be explained by the other variable\\nto calculate the pearson coefficient we need to remove all missing values\\nPlease remember that when two variables are correlated it is possible that:\\nX causes Y or Y causes X\\nZ causes both X and Y\\nX and Y are correlated by chance - a spurious correlation\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf_clean_copy.columns\\n\\nscat1 = sns.regplot(x='age', y = 'cholesterol', fit_reg=True, data = df_clean_copy)\\nplt.xlabel('Age')\\nplt.ylabel('Cholesterol')\\nplt.suptitle('Relationship between age and cholesterol')\\nscat1\\n\\n#the r coefficient is a measure of association, of how closely points are clustered around a line\\n#correlations are always between -1 and 1\\n#r measures solely linear association\\n#association, not causation\\n#it is a number without units\\n#it can mislead in presence of outliers or non linear association -> always draw a scatter plot as well and check visually\\n#when you look at a scatter plot you look at direction form and strength of relationship\\n#if you identify a nonlinear association, with one or more curves, then you know you ought to add nonlinear explanatory\\n#variables to your regression model, to aim to capture this nonlinear association as well.\\n#ecological correlations based on averages can be misleading and overstate strength of associations for individual \\n#units\\nprint('association between age and cholesterol')\\nprint(scipy.stats.pearsonr(df_clean_copy['age'], df_clean_copy['cholesterol']))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"CatsVSDogs\\/Atelier-keras-CatsVSDogs.ipynb\\\".\\nThe first task is:\\nGèle des 4 premiers blocs de convolution\\nEn pratique, et pour pouvoir effectuer ces calculs dans un temps raisonable, nous allons \\\"fine-tuner\\\" seulement le dernier bloc de convolution du modèle, le bloc 5 (couches 16 à 19 dans le summary du modèle précédent) ainsi que le bloc de réseau de neurones que nous avons ajoutés. \\nPour cela on va \\\"geler\\\" (Freeze) les 15 premières couches du modèle pour que leur paramètre ne soit pas optimiser pendant la phase d'apprentissage.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfor layer in model_VGG_LastConv_fcm.layers[:15]:\\n    layer.trainable = False\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Create a PasqalDevice\\nMulti-qubit gates can be applied between qubits in the device, provided that the distance between them is smaller than the so-called Rydberg blocade radius (or control radius), that can be passed as a parameter of the device (in units of the lattice size). Here, we instantiate a PasqalVirtualDevice with 36 qubits and a control radius of $2.1$. \\nThis PasqalVirtualDevice can be used to validate the operations within a Circuit.\\n\",\"targets\":\"from cirq_pasqal.pasqal_device import PasqalConverter\\n\\n# Initialize and create a circuit\\ninitial_circuit = cirq.Circuit()\\ninitial_circuit.append(cirq.CZ(p_qubits[0], p_qubits[1]))\\ninitial_circuit.append(cirq.Z(p_qubits[0]))\\ninitial_circuit.append(cirq.CX(p_qubits[0], p_qubits[2]))\\n\\n# Create a Pasqal device with a control radius of 2.1 (in units of the lattice spacing)\\np_device=PasqalVirtualDevice(control_radius=2.1, qubits=p_qubits)\\n\\n# Validate the circuit using the device\\ntry:\\n    p_device.validate_circuit(initial_circuit)\\nexcept ValueError as e:\\n    # Uh oh!  This circuit does not pass validation.\\n    print(e)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Explore relative difference of different bands\\nwav_, flux_ = load_aces_spectrum([3900, 4.5, 0, 0])\\nwav, flux = wav_selector(wav_, flux_, 0.7, 2.5)\\n\\ntable = []\\ntable.append(\\\"Band, Cond#1, Split,   Masked,  ratio,   Cond#1,   Split,  Masked, ratio\\\")\\ntable.append(\\\"Grad,              False             ,                True              \\\")\\n\\n# Get J band SNR normalization value\\nwav_j, flux_j = convolve_and_resample(\\n    wav, flux, vsini=1, R=100000, band=\\\"J\\\", sampling=3\\n)\\nsnr_norm = snr_constant_band(wav_j, flux_j, snr=100, band=\\\"J\\\")\\n\\nfor band in [\\\"Z\\\", \\\"Y\\\", \\\"J\\\", \\\"H\\\", \\\"K\\\"]:\\n    atm = Atmosphere.from_band(band, bary=True)\\n\\n    w, f = convolve_and_resample(wav, flux, vsini=1, R=100000, band=band, sampling=3)\\n    f \\/= snr_norm\\n\\n    atm = atm.at(w)\\n\\n    a = RVprec_calc_masked(w, f, atm.mask, grad=True)\\n    b = RVprec_calc_masked(w, f, atm.mask, grad=False)\\n    c = rv_precision(w, f, atm.mask, grad=True)\\n    d = rv_precision(w, f, atm.mask, grad=False)\\n    e = rv_precision(w, f, grad=True)\\n    f = rv_precision(w, f, grad=False)\\n\\n    false_ratio = (d - b) \\/ b\\n    true_ratio = (c - a) \\/ a\\n    table.append(\\n        \\\"{0:5}, {1:4.02f}, {2:6.02f}, {3:6.02f}, {4:5.04f}, {5:6.02f}, {6:6.02f}, {7:6.02f}, {8:5.04f}\\\".format(\\n            band,\\n            f.value,\\n            b.value,\\n            d.value,\\n            false_ratio,\\n            e.value,\\n            a.value,\\n            c.value,\\n            true_ratio,\\n        )\\n    )\\n\\nfor line in table:\\n    print(line)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nDifferences between versions with same gradient is at the 4th sf. These are not the correct scale, this will be addressed in the next section.\\nCalculating difference ratios.\\nAssessing the changes to actual Figueira et al. values by not splitting on telluric lines first then applying mask to the weights, or slitting then calculating weights.\\nConvolving the spectra to vsini=1 an R=100k of a M0 spectra in the Z,Y,J,H,K bands to be consistent with paper. \\nUsing Old gradient and new gradient methods to access difference.\\nThe old gradient drops the last pixel, which drops many pixels when spectra is split between telluric lines.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"LongRange\\/PolynomialFit.ipynb\\\".\\nThe first task is:\\nDefine a quality-of-fit measure, $\\\\chi^2$\\nCan you write Python code for it?\\n\",\"targets\":\"\\neq1 = Eq(chi2, Integral(w(r)*(f(r)-f_approx(r,ak))**2,r))\\neq1\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"A helper function is defined to generate samples:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n    def gen_samples(n_samples):\\n        X_all = np.zeros((2, 0))\\n        Y_all = np.zeros(0)\\n    \\n        for i, model in enumerate(models):\\n            Y = np.zeros(n_samples) + i+1\\n            X = np.array(model['sigma']).dot(np.random.randn(2, n_samples)) + np.array(model['mu']).reshape((2,1))\\n    \\n            X_all = np.hstack((X_all, X))\\n            Y_all = np.hstack((Y_all, Y))\\n    \\n        return (X_all, Y_all)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Clip an image by a region of interest\\nIn case you want to display an image over a given region (and not outside), we can clip our dataset using the region as an argument of the clip() method. Let's say that we want to display the ground elevation in France. We can get the geometry of the administrative boundary of France with the FAO feature collection and do the same as before:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Get a feature collection of administrative boundaries.\\ncountries = ee.FeatureCollection('FAO\\/GAUL\\/2015\\/level0').select('ADM0_NAME')\\n\\n# Filter the feature collection to subset France.\\nfrance = countries.filter(ee.Filter.eq('ADM0_NAME', 'France'))\\n\\n# Clip the image by France.\\nelv_fr = elv_img.clip(france)\\n\\n# Create the URL associated with the styled image data.\\nurl = elv_fr.getThumbUrl({\\n    'min': 0, 'max': 2500, 'region': roi, 'dimensions': 512,\\n    'palette': ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']})\\n\\n# Display a thumbnail of elevation in France.\\nImage(url=url)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# should print 0.425558846691\\nprint lasso_coordinate_descent_step(1, np.array([[3.\\/np.sqrt(13),1.\\/np.sqrt(10)],[2.\\/np.sqrt(13),3.\\/np.sqrt(10)]]), \\n                                   np.array([1., 1.]), np.array([1., 4.]), 0.1)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nTo test the function, run the following cell:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Set-up E-step.\\n\\nstep_size = tf.get_variable(\\n    'step_size',\\n    initializer=np.array(0.2, dtype=dtype),\\n    trainable=False)\\n\\nhmc = tfp.mcmc.HamiltonianMonteCarlo(\\n    target_log_prob_fn=unnormalized_posterior_log_prob,\\n    num_leapfrog_steps=2,\\n    step_size=step_size,\\n    step_size_update_fn=tfp.mcmc.make_simple_step_size_update_policy(\\n      num_adaptation_steps=None),\\n    state_gradients_are_stopped=True)\\n\\ninit_random_weights = tf.placeholder(dtype, shape=[len(log_county_uranium_ppm)])\\n\\nposterior_random_weights, kernel_results = tfp.mcmc.sample_chain(\\n    num_results=3,\\n    num_burnin_steps=0,\\n    num_steps_between_results=0,\\n    current_state=init_random_weights,\\n    kernel=hmc)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nこれで、HMC 遷移カーネルを作成して E ステップのセットアップを完了しました。\\n注意:\\n\\n\\nstate_stop_gradient=Trueを使用して、M ステップが  MCMC からの抽出を介してバックプロパゲーションするのを防ぎます。(E ステップでは前の最もよく知られている推定量で意図的にパラメータ化されているため、バックプロパゲーションを行う必要はありません。)\\n\\n\\ntf.placeholder を使用して、最終的に TF グラフを実行するときに、前のイテレーションのランダム MCMC サンプルを次のイテレーションのチェーンの値としてフィードできるようにします。\\n\\n\\nTFP の適応型 step_size ヒューリスティック、tfp.mcmc.hmc_step_size_update_fn を使用します。\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Your code goes here\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSplit the data into train\\/test\\nFor this exercise we'll split the data frame so that 20% of the data is held out for testing, and the remaining data is used for training. Write code to split the data into two dataframes: one for testing and one for training.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%sql macro initialize\\nvar $hello Hello There \\nvar hello You won't see this\\n\\n%%sql macro runit\\necho The value of hello is *{hello}*\\necho {$hello}\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nVar Command\\nThe var (variable) command sets a macro variable to a value. A variable is referred to in the macro script using curly braces {name}. By default the arguments that are used in the macro call are assigned the variable names {1} to {9}. If you use a named argument (option=\\\"value\\\") in the macro call, a variable called {option} will contain the value within the macro.\\nTo set a variable within a macro you would use the var command:\\nvar name value\\nThe variable name can be any name as long as it only includes letters, numbers, underscore _ and $. Variable names are case sensitive so {a} and {A} are different. When the macro finishes executing, the contents of the variables will be lost. If you do want to keep a variable between macros, you should start the name of the variable with a $ sign:\\nvar $name value\\nThis variable will persist between macro calls.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As we have discussed that the linear regression model basically finds the best value for the intercept and slope, which results in a line that best fits the data. To see the value of the intercept and slop calculated by the linear regression algorithm for our dataset, execute the following code.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n#To retrieve the intercept:\\nprint(regressor.intercept_)\\n\\n#For retrieving the slope:\\nprint(regressor.coef_)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# change these to try this notebook out\\n# In \\\"production\\\", these will be replaced by the parameters passed to papermill\\nBUCKET = 'cloud-training-demos-ml'\\nPROJECT = 'cloud-training-demos'\\nREGION = 'us-central1'\\nDEVELOP_MODE = True\\nNBUCKETS = 5 # for embeddings\\nNUM_EXAMPLES = 1000*1000 # assume 1 million examples\\nTRAIN_BATCH_SIZE = 64\\nDNN_HIDDEN_UNITS = '64,32'\\n\\nimport os\\nos.environ['BUCKET'] = BUCKET\\nos.environ['PROJECT'] = PROJECT\\nos.environ['REGION'] = REGION\\n\\n%%bash\\ngcloud config set project $PROJECT\\ngcloud config set compute\\/region $REGION\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSetup\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Data Preparation\\n\",\"targets\":\"from keras import backend as K\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<a id=\\\"cell4\\\"><\\/a>\\n4. Adding Macroeconomic Indicators\\nAs a an indicator of economic state at the time a loan is awarded, we will use S&P 1500 composite index.\\nSource: http:\\/\\/www.econ.yale.edu\\/~shiller\\/data.htm\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Load monthly consumer price index and composite S&P index data\\ncpi_sp = pd.read_excel('ie_data.xls', sep = ' ', skiprows=7)\\n# Use only values starting in 1990\\ncpi_sp  = cpi_sp[cpi_sp['Date']>1989]\\n\\n# Keep only the relevant columns: date (year+month), S&P 1500 index and Consumer Price Index (CPI)\\ncpi_sp = cpi_sp[['Date', 'P', 'CPI']]\\n\\n# Rename the columns\\ncpi_sp.columns = ['Date', 'SP', 'CPI']\\ncpi_sp.head()\\n\\n# Change the format of the date from year.month to datetime (and deal with issues of .10 getting shortented to .1)\\ndef split_date(x):\\n    tmp = str(x).split('.')\\n    if tmp[1] == '1':\\n        tmp[1] = '10'\\n    return tmp\\ncpi_sp['Date_dt'] = cpi_sp['Date'].apply(split_date)\\ns = '-'\\ncpi_sp['Date_dt'] = cpi_sp['Date_dt'].apply(lambda x: s.join(x))\\ncpi_sp['Date_dt'] = cpi_sp['Date_dt'].apply(lambda x: x + '-01')\\ncpi_sp.reset_index()\\ncpi_sp.head(10)\\n\\ncpi_sp.drop('Date', axis = 1, inplace = True)\\n# Rename the columns\\ncpi_sp.columns = ['SP', 'CPI', 'Date']\\n\\n# Adjust S&P based on CPI, relative to January 2016 US Dollar value\\ncpi2016 = float(cpi_sp[cpi_sp['Date'] == '2016-01-01']['CPI'])\\ncpi_sp['CPI_to2016'] = cpi2016\\/cpi_sp['CPI']\\ncpi_sp['SP_to2016'] = cpi_sp['SP'].multiply(cpi_sp['CPI_to2016'])\\ncpi_sp.drop(['CPI', 'SP'], axis = 1, inplace = True)\\ncpi_sp.reset_index(inplace = True, drop = True)\\ncpi_sp.head()\\n\\n# Plot monhtly S&P (adjusted to 2016)\\nfig = plt.figure(figsize = (10,5))\\naxes = fig.add_subplot(1, 1, 1, facecolor ='gainsboro')\\naxes.plot(pd.to_datetime(cpi_sp['Date']), cpi_sp['SP_to2016'], c = 'k', linewidth = 3)\\nplt.xlabel('Year', fontsize = 20)\\nplt.ylabel('S&P 1500', fontsize = 20)\\nplt.xticks(fontsize = 20)\\nplt.yticks(fontsize = 20)\\nplt.tight_layout()\\nplt.show()\\n\\nfig.savefig('1_SP1500.png', dpi = 300)\\n\\n# Use S&P value relative to loan's approval date\\ncpi_sp.columns = [['ApprovalDate', 'CPI_to2016', 'SP_to2016']]\\n\\n# Merge loan data with CPI + S&P data \\n# Keep only the date and set it to first of the month in order to use CPI and SP data\\nloans_7a['ApprovalDate'] = loans_7a['ApprovalDate'].apply(lambda...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Concept\\nA network, more technically known as a graph, is comprised of:\\n\\na set of nodes\\njoined by a set of edges\\n\\nThey can be represented as two lists:\\n\\nA node list: a list of 2-tuples where the first element of each tuple is the representation of the node, and the second element is a dictionary of metadata associated with the node.\\nAn edge list: a list of 3-tuples where the first two elements are the nodes that are connected together, and the third element is a dictionary of metadata associated with the edge.\\n\\nSince this is a social network of people, there'll be attributes for each individual, such as age, and sex. We can grab that data off from the attributes that are stored with each node by adding the data = True argument. Let's get a list of nodes with their attributes.\\n\",\"targets\":\"# networkx will return a list of tuples in the form (node_id, attribute_dictionary)\\nprint(G.nodes(data = True)[:5])\\n\\n# excercise: Count how many males and females are represented in the graph\\nfrom collections import Counter\\nsex = [d['sex'] for _, d in G.nodes(data = True)]\\nCounter(sex)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Programming Assignment 1\\/Predicting sentiment from product reviews with pandas.ipynb\\\".\\nThe first task is:\\n14.\\nNow, let us repeat this exercise to find the \\\"most negative reviews.\\\" Use the prediction probabilities to find the 20 reviews in the test_data with the lowest probability of being classified as a positive review. Repeat the same steps above but make sure you sort in the opposite order.\\nQuiz Question:\\nWhich of the following products are represented in the 20 most negative reviews?\\nCan you write Python code for it?\\n\",\"targets\":\"\\nnegative_idx = np.argsort(test_scores)[:20]\\nprint negative_idx\\nprint test_scores[negative_idx[0]]\\ntest_data.iloc[negative_idx]\",\"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\\/Homework11-Devulapalli.ipynb\\\".\\nThe first task is:\\nLooks like, the month of August is when the Police seem to have gone on a fining spree. \\n15. Make a graph of the amount of revenue collected per day.\\n<< Not too sure on how to get this done>> \\n16. Manually construct a dataframe out of https:\\/\\/dmv.ny.gov\\/statistic\\/2015licinforce-web.pdf (only NYC boroughts - bronx, queens, manhattan, staten island, brooklyn), having columns for borough name, abbreviation, and number of licensed drivers.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndriversdf=pd.read_csv(\\\"drivers.csv\\\")\\n\\ndriversdf.head(6)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"1000 most common words in the training set\\n\",\"targets\":\"#1000 most common words in the training set instead\\ntop_1000 = sorted(train_DF.items(), key=lambda x: x[1],reverse=True)[:1000]\\ntop_1000_index = [dict_index[i[0]] for i in top_1000]\\nX_1000 = X_transp[top_1000_index] \\n\\nZ = linkage(X_1000.toarray(), method='ward' )\\nplt.figure()\\nplt.title('1000 most common words dendrograms for ward linkage type')\\ndn = dendrogram(Z,p=40,truncate_mode='lastp')\\n\\nZ = linkage(X_1000.toarray(), method='complete' )\\nplt.figure()\\nplt.title('1000 most common words dendrograms for complete linkage type')\\ndn = dendrogram(Z,p=40,truncate_mode='lastp')\\n\\nZ = linkage(X_1000.toarray(), method='average' )\\nplt.figure()\\nplt.title('1000 most common words dendrograms for average linkage type')\\ndn = dendrogram(Z,p=40,truncate_mode='lastp')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"FAI_old\\/wordvectors_CodeAlong.ipynb\\\".\\nThe first task is:\\nThis is how you can look up a word vector.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef w2v(w): return vecs[wirdidx[w]] # mispelled 'wordidx' up above... lol\\n\\nw2v('of')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Foundations\\/Python CS\\/Activity 11.ipynb\\\".\\nThe first task is:\\nPlot the results:\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Plot and label the time taken\\nplt.loglog(N, times, marker='o', label='Recursive factorial')\\nplt.xlabel('$n$')\\nplt.ylabel('$t$ (s)')\\n\\n# Show a reference line of O(n)\\nplt.loglog(N, 1e-6*np.array(N), label='$O(n)$')\\n\\n# Add legend\\nplt.legend(loc=0);\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Constants \\/ Parameters\\n\",\"targets\":\"# PARAMETERS (might be overridden by a calling script)\\n\\n# if not calling from another script (batch), SUBNOTEBOOK_FLAG might not be defined\\ntry:\\n    SUBNOTEBOOK_FLAG\\nexcept NameError:\\n    SUBNOTEBOOK_FLAG = False\\n    \\n# Not calling as a sub-script? define params here\\nif not SUBNOTEBOOK_FLAG:\\n    \\n    # SET PARAMETER VARIABLES HERE UNLESS CALLING USING %run FROM ANOTHER NOTEBOOK\\n    \\n    DATADIR = '..\\/data\\/temperatures\\/ISD'\\n    OUTDIR = '..\\/data\\/temperatures'\\n\\n    FTPHOST = 'ftp.ncdc.noaa.gov'\\n    FETCH_STATIONS_LIST_FILE = True\\n\\n    TEMP_COL = 'AT' # The label of the hourly temperature column we make\\/output\\n\\n    # Resampling and interpolation parameters\\n    # spline order used for converting to on-the-hour and filling small gaps\\n    BASE_INTERPOLATION_K = 1 # 1 for linear interpolation\\n    # give special treatment to data gaps longer than...\\n    POTENTIALLY_PROBLEMATIC_GAP_SIZE = pd.Timedelta('03:00:00')\\n\\n    # Time range to use for computing normals (30 year, just like NOAA uses)\\n    NORM_IN_START_DATE = '1986-07-01'\\n    NORM_IN_END_DATE = '2016-07-01'\\n    # Time range or normals to output to use when running 'medfoes on normal temperature' (2 years, avoiding leapyears)\\n    NORM_OUT_START_DATE = '2014-01-01'\\n    NORM_OUT_END_DATE = '2015-12-31 23:59:59'\\n    \\nprint(\\\"Cleaning temperature data for \\\",STATION_CALLSIGN)\\n\\n\\n# Potentially turn interactive figure display off\\nif SUPPRESS_FIGURE_DISPLAY:\\n    plt.ioff()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"%%bash\\nls \\/home\\/jovyan\\/DATA\\/SAM\\/\\n\\n%%bash\\nhead -n 10 \\/home\\/jovyan\\/DATA\\/SAM\\/K562_B-bulk_R1.chr1.sam.25\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLet's take a look at .sam files that were created during iterative mapping:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2) Then we rotated the data around the z axis and the x axis, of 60 and 30 degrees respectively (by this order!) and we ended up with the first plot in this notebook (check it above).\\n\",\"targets\":\"from codefiles.datagen import _rot_mat_z, _rot_mat_x\\n\\n# Rotation angles in degrees\\ntheta_x = 30\\ntheta_z = 60\\n\\n# The rotation matrix is given by: Rot_x * Rot_z\\nrotation_matrix = np.dot(_rot_mat_x(theta=np.radians(theta_x)), _rot_mat_z(theta=np.radians(theta_z)))\\nrotation_matrix\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<p style=\\\"text-align: right; direction: rtl; float: right; clear: both;\\\">\\n    עבור כל תא ברשימת <var>items<\\/var>, שמרנו במקום התואם ברשימת <var>stock<\\/var> את הכמות שנמצאת ממנו בחנות.<br>\\n    יש 4 גזרים, 3 תפוחים ו־2 בננות על המדף בחנות של אדון קשטן.<br>\\n    שליפה של כמות המלאי עבור מוצר כלשהו בחנות תתבצע בצורה הבאה:\\n<\\/p>\\n\",\"targets\":\"def get_stock(item_name, items, stock):\\n    item_index = items.index(item_name)\\n    how_many = stock[item_index]\\n    return how_many\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"201 or 1.7% of the items didn't have both a closed and created time\\n\",\"targets\":\"len(results) - len(timelen)\\n\\n201 \\/ (len(results) + len(timelen))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Back\\n<a id='sol1.8'><\\/a>\\nExercise 1.8: Solution\\n\",\"targets\":\"dice = BoxModel([1, 2, 3, 4, 5, 6], size=2)\\ndice.sim(10000).apply(sum)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<font color=green>Better, but still less accurate than 86.6%<\\/font>\\n\\nTrain a support vector machine (SVM) classifier\\nAmong the SVM options available, we'll use C-Support Vector Classification (SVC)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfrom sklearn.svm import SVC\\nsvc_model = SVC(gamma='auto')\\nsvc_model.fit(X_train,y_train)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Projects\\/Challenges\\/challenge_set_5_prashant.ipynb\\\".\\nThe first task is:\\nHere, the model is using the 'rating' to predict Domestic gross. Since there's 4 ratings, it's predicting one of 4 domestic gross values.\\nChallenge 4\\nCan you write Python code for it?\\n\",\"targets\":\"\\ny4, X4 = patsy.dmatrices('DomesticTotalGross ~ Budget + Runtime + Rating', data=df, return_type=\\\"dataframe\\\")\\n\\nX4.head()\\n\\nmodel = sm.OLS(y4, X4)\\nfit = model.fit()\\nfit.summary()\\n\\nplt.scatter(records, y4, color='g')\\nplt.scatter(records, fit.predict(X4))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2. Create all products of the two lists\\n\",\"targets\":\"l0 = [0, 1, 2]\\nl1 = ['a', 'b', 'c']\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Build VectorAssembler stage\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nfeature_columns = ['onehot_' + c for c in categorical_columns]\\nvectorassembler_stage = VectorAssembler(inputCols=feature_columns, outputCol='features')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"## Open a random image from the pickled files.\\n\\ndef show_rnd_pkl_image():\\n    \\\"\\\"\\\"Function that shows a random pickled image.\\\"\\\"\\\"\\n    # First let's create a list of all the files.\\n    # Create data directory path\\n    dpath = os.path.abspath(os.path.join(os.getcwd(), os.pardir))\\n    dpath = os.path.join(dpath, 'data')\\n\\n    # notMNIST_small directory:\\n    dsmall = os.path.join(dpath, 'notMNIST_small')\\n    # notMNIST_large directory:\\n    dlarge = os.path.join(dpath, 'notMNIST_large')\\n\\n    # Find all pickle files in each directory.\\n    # http:\\/\\/stackoverflow.com\\/a\\/3215392\\n    # Create a list of all nonMNIST_small pickles\\n    lsmall = glob.glob(dsmall + '\\/*.pickle')\\n    # Create a list of all nonMNIST_large pickles\\n    llarge = glob.glob(dlarge + '\\/*.pickle')\\n\\n    # Pick a random pickle to load (either large or small !)\\n    rpklfile = random.choice([lsmall, llarge])\\n    rpklfile = random.choice(rpklfile)\\n\\n    # verify randomness\\n    print(rpklfile)\\n\\n    with open(rpklfile, 'rb') as rf:\\n        imgPkl = pickle.load(rf)\\n\\n    plt.imshow(random.choice(list(imgPkl)))\\n    \\nshow_rnd_pkl_image()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nProblem 2\\nLet's verify that the data still looks good. Displaying a sample of the labels and images from the ndarray. Hint: you can use matplotlib.pyplot.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"5. Logistic Regression\\n5.1 Creating a target function\\nFor simplicity, we choose a target function, $f$, to be a 0\\/1 probability.\\nFor visualization purposes, we choose the domain of interest to be in 2 dimensions, and choose $\\\\mathbf{x}$ to be picked uniformly from the region $\\\\mathcal{X}=\\\\left[-1,1\\\\right] \\\\times \\\\left[-1,1\\\\right]$,\\nwhere $\\\\times$ denotes the Cartesian Product.\\nA random line is created, and to ensure that it falls within the region of interest, it is created from two random points, $(x_0,y_0)$ and $(x_1,y_1)$ which are generated within $\\\\mathcal{X}$.  The equation for this line in slope-intercept form and in the hypothesis \\/ weights can be shown to be:\\nSlope-Intercept Form\\n$$m = - \\\\frac{w_1}{w_2}, c = - \\\\frac{w_0}{w_2}$$\\nHypothesis Weights Form\\n$$\\\\mathbf{w} = \\\\left(-c,-m,1\\\\right)$$\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ndef generate_data(n,seed=None):\\n    if seed is not None:\\n        np.random.seed(seed)\\n    x0 = np.ones(n)\\n    x1 = np.random.uniform(low=-1,high=1,size=(2,n))\\n    return np.vstack((x0,x1)).T\\n\\ndef get_random_line(seed=None):\\n    X = generate_data(2,seed=seed)\\n    x = X[:,1]\\n    y = X[:,2]\\n    m = (y[1]-y[0])\\/(x[1]-x[0])\\n    c = y[0] - m*x[0]\\n    return np.array([-c,-m,1])\\n\\ndef draw_line(ax,w,marker='g--',label=None):\\n    m = -w[1]\\/w[2]\\n    c = -w[0]\\/w[2]\\n    x = np.linspace(-1,1,20)\\n    y = m*x + c\\n    if label is None:\\n        ax.plot(x,y,marker)\\n    else:\\n        ax.plot(x,y,marker,label=label)\\n    \\ndef get_hypothesis(X,w):\\n    h=np.dot(X,w)\\n    return np.sign(h).astype(int)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Bloom Filter\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport math\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"!aws lambda update-function-configuration \\\\\\n   --function-name foo  \\\\\\n   --region us-east-1 \\\\\\n   --timeout timeout-in-seconds \\\\\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nUpdate a function:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Answer 3:  No!\\nAgain, $C$ is not given, so $A$ and $B$ are dependent.\\nQuestion 4:  Is $(A \\\\perp B \\\\mid C)$?\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n@pgm_render\\ndef pgm_question4():\\n    pgm = daft.PGM([4, 4], origin=[0, 0])\\n\\n    # Nodes\\n    pgm.add_node(daft.Node(\\\"c\\\", r\\\"$C$\\\", 2, 3.5, observed=True))\\n    pgm.add_node(daft.Node(\\\"a\\\", r\\\"$A$\\\", 1.3, 2.5))\\n    pgm.add_node(daft.Node(\\\"b\\\", r\\\"$B$\\\", 2.7, 2.5))\\n\\n    # Add in the edges.\\n    pgm.add_edge(\\\"a\\\", \\\"c\\\", head_length=0.08)\\n    pgm.add_edge(\\\"c\\\", \\\"b\\\", head_length=0.08)\\n    \\n    return pgm\\n\\n%%capture\\npgm_question4(\\\"images\\/pgm\\/question4.png\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Getting Started.ipynb\\\".\\nThe first task is:\\nI used the as_of parameter here to indicate that this data from January. When as_of is ommited, the dimension will always use the current date.\\nUpdating dimension with new data\\nNow lets import a new clients table:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf = pd.read_csv('clients 2015-02.csv')\\ndf\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"34. Microphysics Precipitation --&gt; Large Scale Precipitation\\nProperties of the large scale precipitation scheme\\n34.1. Scheme Name\\nIs Required: FALSE&nbsp;&nbsp;&nbsp;&nbsp;Type: STRING&nbsp;&nbsp;&nbsp;&nbsp;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(\\\"Hourdin et al (2006)\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"A side effect of this is that a yield statement in some parts of a list comprehension causes it to evaluate to a generator object.\\n\",\"targets\":\"[i for i in range(3) if (yield i)]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Fixed-width\\nh1(data, \\\"fixed_width\\\", bin_width=6).numpy_bins  \\n\\n# Numpy-like\\nprint(\\\"Expected:\\\", np.histogram(data, 5)[1])\\n\\nprint(\\\"We got:\\\", h1(data, \\\"numpy\\\", bin_count=5).numpy_bins)\\n\\n# Integer - centered around integers; useful for integer data\\nh1(data, \\\"integer\\\").numpy_bins     \\n\\n# Exponential - positive numbers required\\nh1(np.abs(data), \\\"exponential\\\").numpy_bins      # We 'abs' the values\\n\\n# Quantile - each bin should have a similar statistical importance\\nh1(data, \\\"quantile\\\", bin_count=5).numpy_bins\\n\\n\\n# Human - as friendly to your plots as possible, you may set an approximate number of bins\\nh1(data, \\\"human\\\").numpy_bins             \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThese names can be used as the second parameter of the h1 function:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Feel free to change these parameters according to your system's configuration\\n\\nBATCH_SIZE = 64\\nBUFFER_SIZE = 1000\\nembedding_dim = 256\\nunits = 512\\nvocab_size = top_k + 1\\nnum_steps = len(img_name_train) \\/\\/ BATCH_SIZE\\n# Shape of the vector extracted from InceptionV3 is (64, 2048)\\n# These two variables represent that vector shape\\nfeatures_shape = 2048\\nattention_features_shape = 64\\n\\n# Load the numpy files\\ndef map_func(img_name, cap):\\n  img_tensor = np.load(img_name.decode('utf-8')+'.npy')\\n  return img_tensor, cap\\n\\ndataset = tf.data.Dataset.from_tensor_slices((img_name_train, cap_train))\\n\\n# Use map to load the numpy files in parallel\\ndataset = dataset.map(lambda item1, item2: tf.numpy_function(\\n          map_func, [item1, item2], [tf.float32, tf.int32]),\\n          num_parallel_calls=tf.data.experimental.AUTOTUNE)\\n\\n# Shuffle and batch\\ndataset = dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE)\\ndataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n创建用于训练的 tf.data 数据集\\n我们的图像和描述已准备就绪！接下来，让我们创建一个 tf.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 \\\"2018\\/materials\\/boulder\\/day4-text-analysis\\/Day 4, Lecture 2 - Sentiment analysis.ipynb\\\".\\nThe first task is:\\nOnce we have a sentiment score for each presidential sentence, we can compute the average across all sentences within a biography, and sort the resulting average presidential sentiment.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmean_potus_sentiment = pd.Series({potus:np.mean(scores) for potus,scores in potus_sentiments.items()})\\nmean_potus_sentiment.sort_values(ascending=False)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"5. getTestResults; storeTestResults; pull some statistics\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ntest_results = get.getTestResults(score, y_test)\\ntest_results.head(10)\\n\\nstore.storeTestResults(test_results)\\n\\n## as we can see, the data is actually stored\\npull.pullTestResults(main.session_id).head()\\n\\nroc = pull.pullROC(main.session_id)\\nliftchart = pull.pullLiftChart(main.session_id)\\n\\nfg = plt.figure(figsize=(10,5))\\nadj = plt.subplots_adjust(hspace=0.4,wspace=0.2)\\n\\nsp = plt.subplot(1,2,1)\\nl1 = plt.plot(roc.false_positive_rate, roc.true_positive_rate)\\ntl = plt.title(\\\"ROC curve\\\")\\n\\nsp = plt.subplot(1,2,2)\\nl1 = plt.plot(liftchart.population, liftchart.target_population)\\ntl = plt.title(\\\"Liftchart\\\")\\n\\nplt.show()\\n\\npull.pullAccuracy(main.session_id, 0.5, 'population')\\n\\npull.pullAccuracy(main.session_id, 0.5, 'probability')\\n\\npull.pullConfMatrix(main.session_id, 0.5, 'probability')\\n\\nthreshold_value = 0.5 \\nthreshold_type = \\\"population\\\"\\nmain.updateThreshold(model_id, threshold_value, threshold_type)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Combinational\\nThe combinational syntax allows you to use if\\/else statements.  These conditional statements are not executed in Python, instead they are lowered to hardware muxes.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n@m.circuit.combinational\\ndef basic_if(I: m.Bits[2], S: m.Bit) -> m.Bit:\\n    if S:\\n        x = I[0]\\n    else:\\n        x = I[1]\\n    return x\\nprint(repr(basic_if.circuit_definition))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create a BigQuery dataset\\nIf you already have a dataset ready to save tables to, skip this step.\\nSet the name of your BigQuery dataset below. Dataset IDs\\nmust be alphanumeric (plus underscores) and must be at most 1024 characters\\nlong.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nDATASET_NAME = \\\"\\\" # Name the dataset you'd like to save the output to\\nLOCATION = \\\"US\\\"\\n\\n! bq mk --location=$LOCATION --dataset $PROJECT_ID_BILLING:$DATASET_NAME\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#print df.shape\\nplt.plot(df['ManuleY']+np.random.randn(df.shape[0])*0.1,df['CatalogY']+np.random.randn(df.shape[0])*0.1,'.')\\nplt.xlim([-0.4,1.3])\\nplt.ylim([-0.4,1.3])\\nplt.xlabel('ManuleY')\\nplt.ylabel('CatalogY')\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLet's first have compare the Manuel selected signals with the catalog selected signals. \\nAs a reminder: \\n- Manuel Y is those signals selected by human eye as looks like transit shape\\n- Catalog Y is those stars have signals injected in them at the original input catalog that we determined have enough signal to noise to be recovered\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Acima podemos ver que a região 1 teve o maior número de ocorrências criminais\\nPodemos agora ver quais são essas ocorrências de forma mais detalhada\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nregiao_1_detalhe = df_abril[df_abril['CLUSTER'] == 1]\\nregiao_1_detalhe\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Congratulations! You've now successfully completed the tutorial. You started Clipper, created an application and queried it from a frontend client, and deployed two models trained in two different machine learning frameworks (Scikit-Learn and TensorFlow) to the running system.\\nHead back to the notebook from part 1. When you're done watching the accuracy of your application, stop the cell (hit the little \\\"stop\\\" square in the notebook toolbar).\\n<img src=\\\"img\\/warning.jpg\\\" style=\\\"width: 400px;\\\"\\/>\\n\\nThis step will stop and remove all Clipper Docker containers running on the host. This command will not affect other Docker containers running on the host machine.\\n\\nCleanup\\nWhen you're completely done with the tutorial and want to shut down your Clipper instance, you can run the stop_all() command to stop all the Clipper Docker containers.\\nIf you check the accuracy of your frontend application a final time, you should see accuracy around 88%. If the accuracy is below that, you can try sending more feedback to increase the weight on the TensorFlow model even more.\\n\",\"targets\":\"clipper.stop_all()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Create the model version\\nCreating the version will take ~5-10 minutes. Note that your first deploy may take longer.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Each time you create a version the name should be unique\\nVERSION = 'v1'\\n\\n# Create the version with gcloud\\nexplain_method = 'integrated-gradients'\\n!gcloud beta ai-platform versions create $VERSION --region=$REGION \\\\\\n--model $MODEL \\\\\\n--origin $export_path \\\\\\n--runtime-version 1.15 \\\\\\n--framework TENSORFLOW \\\\\\n--python-version 3.7 \\\\\\n--machine-type n1-standard-4 \\\\\\n--explanation-method $explain_method \\\\\\n--num-integral-steps 25\\n\\n# Make sure the model deployed correctly. State should be `READY` in the following log\\n!gcloud ai-platform versions describe $VERSION --model $MODEL\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# data exploration\\nprint(data_raw.shape)\\ndata_raw.head(n = 5)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nAfter loading the data we can have s look at its first several rows.\",\"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)\\n\",\"targets\":\"test_batch_size_ph = tf.placeholder(tf.int32)\\n\\ntest_batch_size_ph.shape\\n\\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    lstm_layers = 2\\n    cell = tf.contrib.rnn.BasicLSTMCell(num_units=rnn_size)\\n#     drop = tf.contrib.rnn.DropoutWrapper(cell)\\n    multi = tf.contrib.rnn.MultiRNNCell([cell] * lstm_layers)\\n    initial_state = multi.zero_state(batch_size, tf.float32)\\n    initial_state =  tf.identity(initial_state, \\\"initial_state\\\")\\n    return multi, 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\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"12. Soil --&gt; Hydrology --&gt; Freezing\\nTODO\\n12.1. Number Of Ground Ice Layers\\nIs Required: TRUE&nbsp;&nbsp;&nbsp;&nbsp;Type: INTEGER&nbsp;&nbsp;&nbsp;&nbsp;Cardinality: 1.1\\nHow many soil layers may contain ground ice\\n\",\"targets\":\"# PROPERTY ID - DO NOT EDIT !  \\nDOC.set_id('cmip6.land.soil.hydrology.freezing.number_of_ground_ice_layers')  \\n\\n# PROPERTY VALUE: \\n# Set as follows: DOC.set_value(value)  \\nDOC.set_value(6)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# This should tell us that instance p is a Parabola type of class:\\n\\np.__class__\\n\\np.__class__ == Parabola\\n\\np.__class__.__name__\\n\\n# You can see it's a string from the tick\\n# marks, but also:\\n\\ntype(p.__class__.__name__)\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nA couple of attributes of classes:\",\"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\\/Lab3_AnaliseExploratoria.ipynb\\\".\\nThe first task is:\\nNotem que lemos o histograma da seguinte maneira: em cerca de 50 meses foram observadas entre 1750 e 2000 prisões. Porém, não sabemos precisar em quais meses houve um aumento ou redução das prisões. Isso deve ser observado através de um gráfico de linha.\\n(3e) Box-plot\\nO Box-plot é um gráfico muito utilizado em estatística para visualizar o resumo estatístico de uma variável.\\nPara esse exercício vamos plotar duas box-plot sobre a média do número de prisões durante os meses analisados para os crimes do tipo ROBBERY e ASSAULT.\\nO mapeamento é exatamente o mesmo do exercício anterior, porém filtrando para o tipo de roubo analisado.\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# EXERCICIO\\n\\nparseDayMonth = lambda x: '{}-{}'.format(x.month,x.year)\\n\\nbookedRDD = (CrimeHeadlessRDD\\n             .filter(lambda x: u'\\\"ARREST' in x.Resolution)#<COMPLETAR>\\n             .map(lambda y:(parseMonthYear(y.Dates),1))#<COMPLETAR>\\n             .reduceByKey(add)#<COMPLETAR>\\n             .map(lambda z:z[1])#.<COMPLETAR>\\n            )\\n\\n\\nrobberyBookedRDD = (CrimeHeadlessRDD\\n                    .filter(lambda x: u'\\\"ARREST' in x.Resolution and x.Category == \\\"ROBBERY\\\")#<COMPLETAR>\\n                    .map(lambda y:(parseMonthYear(y.Dates),1))#<COMPLETAR>\\n                    .reduceByKey(add)#<COMPLETAR>\\n                    .map(lambda z:z[1])#.<COMPLETAR>\\n                   )\\n\\nassaultBookedRDD = (CrimeHeadlessRDD\\n                    .filter(lambda x: u'\\\"ARREST' in x.Resolution and x.Category == \\\"ASSAULT\\\")#<COMPLETAR>\\n                    .map(lambda y:(parseMonthYear(y.Dates),1))#<COMPLETAR>\\n                    .reduceByKey(add)#<COMPLETAR>\\n                    .map(lambda z:z[1])#.<COMPLETAR>\\n                   )\\n\\nrobData = robberyBookedRDD.collect()\\nassData = assaultBookedRDD.collect()\\n\\nassert robData[0]==27,'valores incorretos'\\nprint 'ok'\\nassert assData[0]==152,'valores incorretos'\\nprint 'ok'\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Medindo strings\\nwords = ['Platão', 'Sócrates', 'Eu']\\nfor w in words:\\n    print(w, len(w))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nJá vimos que podem existir um ou mais blocos elif, e o bloco else é opcional. O comando elif é uma abreviação para ``else if'', sendo útil para reduzir a quantidade de indentações. Uma sequência if ... elif ... elif ... é o substituto para os comandos switch ou case disponíveis noutras linguagens de programação.\\nPython: de volta  ao comando for\\nComo vimos no Python o comando for permite iterar sobre objectos de qualquer sequência (uma lista ou uma string) ou um conjunto, nas sequências o ciclo for segue a ordem pela qual os objectos aparecem na sequência. Por examplo:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Altura del edificio\\n\",\"targets\":\"plt.plot(ap.index,ap.h-ap.h.min(),'r-',lw=2)\\nplt.title('La Altura Entrebosques del S3 al 26 es %g m' %round( (ap.h.max()-ap.h.min()),1 ))\\nplt.xlabel('Tiempo transcurrido (s)',size=20)\\nplt.ylabel('Altura del edificio (m)',size=20)\\n\\nap.p.min()\\n\\nptoh(ap.p.min())\\n\\nprint('floor')\\nraw_input()\\nprint('head')\\nraw_input()\\nprint('height')\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Curiously, the total output of agriculture is higher, if cities whithout agriculure die.\\nFor the other outputs, leaving settlements without agriculture alive increases the output.\\nApparently, climate variability has big impact on Income from agriculture, little impact on income from ecosystems and no impact on income from trade.\\nAll of this leaves me wondering \\n* 1) if trade links are removed propperly when cities population shrinks.\\nIt looks as if trade links only vanish if settlements die. Check this!\\n* 2) What impact the decay of the ecosystem and climate variability actually has on the income from ecosystem services. It seems like the impact ist negligible and in the original model, the impact came primarily from loss of settlements. More details on this in experiment 4\\n* 3) If this behavior depends on the weights of income from agriculture and ecosystem services relative to the income from trade. More on this in Experiment 2\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nkey=['total_trade_links']\\nlevel=['observables']\\nunstack = ['kill_cropless']\\n\\nplotlines(data, level, key, unstack)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Building a logistic regression classifier with Scikit-Learn\\n\",\"targets\":\"#cat_to_num(data['Sex'])\\nfeatures = prepare_data(data_train)\\nfeatures[:5]\\n\\nfrom sklearn.linear_model import LogisticRegression\\nmodel = LogisticRegression()\\nmodel.fit(features, data_train[\\\"Survived\\\"])\\n\\n# Make predictions\\nmodel.predict(prepare_data(data_test))\\n\\n# The accuracy of the model on the test data\\n# (this will be introduced in more details in chapter 4)\\nmodel.score(prepare_data(data_test), data_test[\\\"Survived\\\"])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<div class=\\\"alert alert-info\\\"><h4>Note<\\/h4><p>The MNE sample dataset should be downloaded automatically but be\\n          patient (approx. 2GB)<\\/p><\\/div>\\n\\nRead data from file:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nraw = mne.io.read_raw_fif(raw_fname, add_eeg_ref=False)\\nprint(raw)\\nprint(raw.info)\",\"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-Pandas-Data-Tables\\/Ten-Minute-Tutorial_class.ipynb\\\".\\nThe first task is:\\nConverting between time span representations\\nCan you write Python code for it?\\n\",\"targets\":\"\\nrng = pd.date_range('1\\/1\\/2012', periods=5, freq='M')\\nts = pd.Series(np.random.randn(len(rng)), index=rng)\\nts\\n\\nps = ts.to_period()\\nps\\n\\nps.to_timestamp()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Game of Life.ipynb\\\".\\nThe first task is:\\nThe iteration step\\nZ: Should be a matrix of ones and zeros which represents the state of the board. The board will then be iterated and returned as a matrix of ones and zeros.\\n\\nThis function will add in the randomness according to the parameters listed above.\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef iterate(Z):\\n    # Count neighbours\\n    N = (Z[0:-2,0:-2] + Z[0:-2,1:-1] + Z[0:-2,2:] +\\n         Z[1:-1,0:-2]                + Z[1:-1,2:] +\\n         Z[2:  ,0:-2] + Z[2:  ,1:-1] + Z[2:  ,2:])\\n\\n    # Apply rules\\n    birth = (N==3) & (Z[1:-1,1:-1]==0)\\n    survive = ((N==2) | (N==3)) & (Z[1:-1,1:-1]==1)\\n    # Add randomess\\n    R_1 = (N==1) * (np.random.randint(0,k_1, np.array(Z.shape) - np.array([2,2])) == 0)\\n    R_2 = (N==2) * (np.random.randint(0,k_2, np.array(Z.shape) - np.array([2,2])) == 0)\\n    R_3 = (N==3) * (np.random.randint(0,k_3, np.array(Z.shape) - np.array([2,2])) == 0)\\n    R_4 = (N==4) * (np.random.randint(0,k_4, np.array(Z.shape) - np.array([2,2])) == 0)   \\n    Z[...] = 0\\n    Z[1:-1,1:-1][birth | survive] = 1\\n    Z[1:-1,1:-1][R_1] = 1\\n    Z[1:-1,1:-1][R_2] = 0\\n    Z[1:-1,1:-1][R_3] = 0\\n    Z[1:-1,1:-1][R_2] = 1\\n    return Z\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"17-09-27-AWS Machine Learning A Complete Guide With Python\\/04 - Linear Regression\\/02 - ml_linear_examples.ipynb\\\".\\nThe first task is:\\n<h4>AWS ML Estimated\\/Predicted<\\/h4>\\nEstimated\\/Predicted value is reported as 'score'. <br>\\nTag is the row identifier\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf_predicted.head()\\n\\ndf_predicted.columns = [\\\"Row\\\", \\\"y_predicted\\\"]\\n\\ndf_predicted.index = df_predicted.Row\\n\\ndf_predicted.head()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Average CTR\\n| Column  |  Description |\\n|---|---|\\n|avg_ctr_ad_id, avg_ctr_publisher_id, avg_ctr_advertiser_id, avg_ctr_campain_id, avg_ctr_entity_id_country … | Average CTR (#clicks \\/ #views) given some categorical combinations and CTR confidence (details on Part II post). Eg. P(click  category01, category02).\\n\",\"targets\":\"events.cache()\\nclicks_train.cache()\\ndocuments_meta.cache()\\npromoted_contents.cache()\\n\\navg_ctrs_by_ad_id = clicks_train.groupBy(\\\"ad_id\\\").agg(F.avg(\\\"clicked\\\").alias(\\\"avg_ctr_by_ad_id\\\"))\\n%show avg_ctrs_by_ad_id\\n\\navg_ctrs_by_campaign_id = (clicks_train\\n.join(promoted_contents, on = \\\"ad_id\\\")\\n.groupBy(\\\"campaign_id\\\")\\n.agg(F.avg(\\\"clicked\\\").alias(\\\"avg_ctr_by_campaign_id\\\")))\\n\\n%show avg_ctrs_by_campaign_id\\n\\navg_ctrs_by_advertiser_id = (clicks_train\\n.join(promoted_contents, on = \\\"ad_id\\\")\\n.groupBy(\\\"advertiser_id\\\")\\n.agg(F.avg(\\\"clicked\\\").alias(\\\"avg_ctr_by_advertiser_id\\\"))\\n.cache()\\n)\\n\\n%show avg_ctrs_by_advertiser_id\\n\\navg_ctrs_by_document_id = (clicks_train\\n.join(promoted_contents, on = \\\"ad_id\\\")\\n.groupBy(\\\"document_id\\\")\\n.agg(F.avg(\\\"clicked\\\").alias(\\\"avg_ctr_by_document_id\\\"))\\n.cache()\\n)\\n\\n%show avg_ctrs_by_document_id\\n\\navg_ctrs_by_time = (events\\n .join(documents_meta, on = \\\"document_id\\\", how = \\\"left\\\")\\n .join(clicks_train, on = \\\"display_id\\\", how = \\\"left\\\")\\n .join(promoted_contents, on = \\\"ad_id\\\", how = \\\"left\\\")\\n .withColumn(\\\"total_clicks_by_ad_id\\\"\\n    , F.expr(\\\"SUM(clicked) OVER (PARTITION BY ad_id ORDER BY timestamp ROWS BETWEEN UNBOUNDED PRECEDING AND -1 FOLLOWING)\\\"))\\n .withColumn(\\\"total_events_by_ad_id\\\"\\n    , F.expr(\\\"COUNT(*) OVER (PARTITION BY ad_id ORDER BY timestamp ROWS BETWEEN UNBOUNDED PRECEDING AND -1 FOLLOWING)\\\"))\\n\\n .withColumn(\\\"total_clicks_by_advertiser_id\\\"\\n    , F.expr(\\\"SUM(clicked) OVER (PARTITION BY advertiser_id ORDER BY timestamp ROWS BETWEEN UNBOUNDED PRECEDING AND -1 FOLLOWING)\\\"))\\n .withColumn(\\\"total_events_by_advertiser_id\\\"\\n    , F.expr(\\\"COUNT(*) OVER (PARTITION BY advertiser_id ORDER BY timestamp ROWS BETWEEN UNBOUNDED PRECEDING AND -1 FOLLOWING)\\\"))\\n\\n .withColumn(\\\"total_clicks_by_campaign_id\\\"\\n    , F.expr(\\\"SUM(clicked) OVER (PARTITION BY campaign_id ORDER BY timestamp ROWS BETWEEN UNBOUNDED PRECEDING AND -1 FOLLOWING)\\\"))\\n .withColumn(\\\"total_events_by_campaign_id\\\"\\n    , F.expr(\\\"COUNT(*) OVER (PARTITION BY campaign_id ORDER BY timestamp ROWS BETWEEN UNBOUNDED PRECEDING AND -1 FOLLOWING)\\\"))\\n\\n...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#the LJ potential with the central bead keeps all the beads from simply collapsing into the center\\nsystem.non_bonded_inter[1, 0].lennard_jones.set_params(\\n    epsilon=eps_cs, sigma=sig_cs,\\n    cutoff=sig_cs*np.power(2.,1.\\/6.), shift=\\\"auto\\\")\\n#the LJ potential (WCA potential) between surface beads causes them to be roughly equidistant on the colloid surface\\nsystem.non_bonded_inter[1, 1].lennard_jones.set_params(\\n    epsilon=eps_ss, sigma=sig_ss,\\n    cutoff=sig_ss*np.power(2.,1.\\/6.), shift=\\\"auto\\\")\\n\\n#the harmonic potential pulls surface beads towards the central colloid bead\\ncol_center_surface_bond = interactions.HarmonicBond(k=3000., r_0=harmonic_radius)\\nsystem.bonded_inter.add(col_center_surface_bond)\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThe $periodicity$ parameter indicates that the system is periodic in all three\\ndimensions. Note that the lattice-Boltzmann algorithm requires periodicity in all three directions (although\\nthis can be modified using boundaries, a topic not covered in this tutorial). \\n4 Setting up the Raspberry\\nSetting up the raspberry is a non-trivial task. The main problem lies in creating a relatively\\nuniform distribution of beads on the surface of the colloid. In general one should take about 1 bead per lattice-Boltzmann grid\\npoint on the surface to ensure that there are no holes in the surface. The behavior of the colloid can be further improved by placing\\nbeads inside the colloid, though this is not done in this example script. In our example\\nwe first define a harmonic interaction causing the surface beads to be attracted\\nto the center, and a Lennard-Jones interaction preventing the beads from entering the colloid. There is also a Lennard-Jones\\npotential between the surface beads to get them to distribute evenly on the surface.\",\"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\\/Tilting_Estimates_of_ATT.ipynb\\\".\\nThe first task is:\\nHide Runtime warning messages to clean up output.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nimport warnings\\n\\ndef fxn():\\n    warnings.warn(\\\"runtime\\\", RuntimeWarning)\\n\\nwith warnings.catch_warnings():\\n    warnings.simplefilter(\\\"ignore\\\")\\n    fxn()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Lab 7 - Time Evolution.ipynb\\\".\\nThe first task is:\\nThe next line calls a Schrödinger equation solver (sesolve). The arguments are the Hamiltonian, the starting state $\\\\lvert+z\\\\rangle$ (pz), the time values, a list of operators, and the arguments to the function H_t. sesolve returns many things, but the expect method is most useful, it gives the expectation values of the four operators in the operator list. Notice the fourth operator is the $\\\\lvert-z\\\\rangle$ projection operator. It's expectation value is $P(\\\\lvert-z\\\\rangle,t)$\\nCan you write Python code for it?\\n\",\"targets\":\"\\nresult5 = sesolve(H, pz, t, [Sx, Sy, Sz, mz*mz.dag()],args)\\nsx, sy, sz, Pmz = result5.expect\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<h3>Matritzen Multiplikation<\\/h3>\\n\",\"targets\":\"ax = np.arange(10)\\nay = np.array([ax,ax])\\n#Skalar multiplikation\\nay*2\\n\\nnp.dot(ay,ay.reshape(10,2)) #Dot product\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"<br>\\n<br>\\nIncreasing point size with distance from the origin\\n[back to top]\\n\",\"targets\":\"import numpy as np\\nimport matplotlib.pyplot as plt\\n\\nfig = plt.figure(figsize=(8,6))\\n\\n# Generating a Gaussion dataset:\\n# creating random vectors from the multivariate normal distribution \\n# given mean and covariance \\nmu_vec1 = np.array([0,0])\\ncov_mat1 = np.array([[1,0],[0,1]])\\nX = np.random.multivariate_normal(mu_vec1, cov_mat1, 500)\\n\\nR = X**2\\nR_sum = R.sum(axis=1)\\nplt.scatter(X[:, 0], X[:, 1], \\n            color='gray', \\n            marker='o', \\n            s=32. * R_sum,\\n            edgecolor='black',\\n            alpha=0.5)\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# 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\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLoad the database webserver.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Add a 2nd polygon to \\\"P\\\"\\nxpts = [14,14,16,16]\\nypts = [0,2,2,0]\\nP.add_polygon([xpts,ypts], layer = 1)\\n\\nqp(P) # Quickplot the \\\"P\\\" with its 2 polygons\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nNow we're getting somewhere!  We've only had to make the polygon once, but we're able to reuse it as many times as we want.\\nModifying the referenced geometry\\nNow, a question naturally follows this:  What happens when you change the original geometry that the reference points to?  In our case, our references in D all point to the Device P that with the original polygon.  Let's try adding a second polygon to P.\\nFirst we add the second polygon and make sure P looks like we expect:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"2°) Fitting the other cost data\\nIn this section, we fit the data generated by the quadratic, exponential, and logarithmic cost function and recover the parameters $\\\\text{RC}$ and $\\\\theta_{11}$ and $\\\\theta_{12}$. We do not illustrate the impact of misspecification for those cost functions.\\nA. Fitting the true quadratic cost function\\nWe start by initializing a DynamicLogit instance, and fit the likelihood function to the data. \\nRecall that in the quadratic model:\\n$$\\\\text{RC} = 20$$\\n$$\\\\theta_{11} = 0.5$$\\n$$\\\\theta_{12} = 0.01$$\\n\",\"targets\":\"quad_to_quad = DynamicLogit(quad_dataframe, \\\"Choice\\\", \\\"State\\\", p, quad_cost, npars=3)\\nquad_to_quad.fit_likelihood(x0=[20, 1, 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 \\\"0101_GettingStartedWithPython.ipynb\\\".\\nThe first task is:\\nA few imprtant notes:\\n* Indentation is not just here for better readability of the code but it is actually necessary for Python to correctly interpret the code.\\n* Though it is not necessary, we initiate seqSum = 0 here. Otherwise, if we run the code repeatedly we add to the previous total!\\n* value takes on every value in array seq. In the first loop value=10, second loop value=9, etc. \\nLoops can be nested, too. Here's an example.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nseq = seq.reshape(2, 5)\\nseq\\n\\nseqSum = 0\\nrow = seq.shape[0]\\ncol = seq.shape[1]\\n\\nfor rowIndex in range(0, row):\\n    for colIndex in range(0, col):\\n        seqSum = seqSum + seq[rowIndex, colIndex]\\n        \\nseqSum\",\"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-14-Ordinary-Differential-Equations.ipynb\\\".\\nThe first task is:\\nWe substitute the initial condition and then solve for C1.  Afterwards we substitute C1 back into the general solution and plot the result.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nparticularSolution = solutionToEquation.subs([(current(t),0),(t,0)])\\nparticularSolution\\n\\nsolutionSet = solveset(particularSolution,C1)\\nsolutionList = [a for a in solutionSet]\\nsolutionSet\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"3 - Introducing Pandas.ipynb\\\".\\nThe first task is:\\nCount the unique values:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmonths = gig_months.value_counts()\\nmonths\\n\\n# matplotlib has lots of options for customization\\nax = months.sort_index().plot.bar(table=True, figsize=(10,5))\\nax.get_xaxis().set_visible(False)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"As you may have noticed, the vectorized implementation is much cleaner and more efficient. For bigger vectors\\/matrices, the differences in running time become even bigger. \\nNote that np.dot() performs a matrix-matrix or matrix-vector multiplication. This is different from np.multiply() and the * operator (which is equivalent to  .* in Matlab\\/Octave), which performs an element-wise multiplication.\\n2.1 Implement the L1 and L2 loss functions\\nExercise: Implement the numpy vectorized version of the L1 loss. You may find the function abs(x) (absolute value of x) useful.\\nReminder:\\n- The loss is used to evaluate the performance of your model. The bigger your loss is, the more different your predictions ($ \\\\hat{y} $) are from the true values ($y$). In deep learning, you use optimization algorithms like Gradient Descent to train your model and to minimize the cost.\\n- L1 loss is defined as:\\n$$\\\\begin{align} & L_1(\\\\hat{y}, y) = \\\\sum_{i=0}^m|y^{(i)} - \\\\hat{y}^{(i)}| \\\\end{align}\\\\tag{6}$$\\n\",\"targets\":\"# GRADED FUNCTION: L1\\n\\ndef L1(yhat, y):\\n    \\\"\\\"\\\"\\n    Arguments:\\n    yhat -- vector of size m (predicted labels)\\n    y -- vector of size m (true labels)\\n    \\n    Returns:\\n    loss -- the value of the L1 loss function defined above\\n    \\\"\\\"\\\"\\n    \\n    ### START CODE HERE ### (≈ 1 line of code)\\n    diff = np.abs(np.subtract(yhat, y))\\n    loss = np.sum(diff)\\n    ### END CODE HERE ###\\n    \\n    return loss\\n\\nyhat = np.array([.9, 0.2, 0.1, .4, .9])\\ny = np.array([1, 0, 0, 1, 1])\\nprint(\\\"L1 = \\\" + str(L1(yhat,y)))\",\"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 RNN by implementing the following functions below:\\n- get_inputs\\n- get_init_cell\\n- get_embed\\n- build_rnn\\n- build_nn\\n- get_batches\\nCheck the Version of TensorFlow and Access to GPU\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL\\n\\\"\\\"\\\"\\nfrom distutils.version import LooseVersion\\nimport warnings\\nimport tensorflow as tf\\n\\n# Check TensorFlow Version\\nassert LooseVersion(tf.__version__) >= LooseVersion('1.0'), 'Please use TensorFlow version 1.0 or newer'\\nprint('TensorFlow Version: {}'.format(tf.__version__))\\n\\n# Check for a GPU\\nif not tf.test.gpu_device_name():\\n    warnings.warn('No GPU found. Please use a GPU to train your neural network.')\\nelse:\\n    print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))\\n\\ndef get_inputs():\\n    \\\"\\\"\\\"\\n    Create TF Placeholders for input, targets, and learning rate.\\n    :return: Tuple (input, targets, learning rate)\\n    \\\"\\\"\\\"\\n    inputs = tf.placeholder(tf.int32, shape=(None, None), name=\\\"input\\\")\\n    targets = tf.placeholder(tf.int32, shape=(None, None), name=\\\"target\\\")\\n    learning_rate = tf.placeholder(tf.float32, name=\\\"learning_rate\\\")\\n    return inputs, targets, learning_rate\\n\\n\\n\\\"\\\"\\\"\\nDON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE\\n\\\"\\\"\\\"\\ntests.test_get_inputs(get_inputs)\",\"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-NLP\\/word-vectors.ipynb\\\".\\nThe first task is:\\nThe arrows are different since we have selected two specific dimensions and not the reduced PCA ones and words are more spread, not necessarily clustered together.  \\nBut note that similar words like 'village' and 'town' or 'country' and 'continent' tend to point in the same direction.\\nAlso, note that 'sad' and 'happy' looks close to each other; however, the vectors point in opposite directions.\\nIn this chart, one can figure out the angles and distances between the words. Some words are close in both kinds of similarity metrics.\\nWord distance\\nNow we will explore another peculiarity of the word vectors: how the distance between two vectors give an indication of the words similarity.\\nWe plot the words 'sad', 'happy', 'town', and 'village' as in the previous chart. In this same chart, display the vector from 'village' to 'town' and the vector from 'sad' to 'happy'.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nwords = ['sad', 'happy', 'town', 'village']\\n\\nembeddedWords = np.array([getVector(word) for word in words]) # Convert each word to its vector representation\\n\\nfig, ax = plt.subplots(figsize = (10, 10)) # Create custom size image\\n\\ncol1 = 3 # Select the column for the x axe\\ncol2 = 2 # Select the column for the y axe\\n\\n# Print an arrow for each word\\nfor word in embeddedWords:\\n    ax.arrow(0, 0, word[col1], word[col2], head_width=0.0005, head_length=0.0005, fc='r', ec='r', width = 1e-5)\\n    \\n# print the vector difference between village and town\\nvillage = getVector('village')\\ntown = getVector('town')\\ndiff = town - village\\nax.arrow(village[col1], village[col2], diff[col1], diff[col2], fc='b', ec='b', width = 1e-5)\\n\\n# print the vector difference between village and town\\nsad = getVector('sad')\\nhappy = getVector('happy')\\ndiff = happy - sad\\nax.arrow(sad[col1], sad[col2], diff[col1], diff[col2], fc='b', ec='b', width = 1e-5)\\n\\n\\nax.scatter(embeddedWords[:, col1], embeddedWords[:, col2]); # Plot a dot for each word\\n\\n# Add the word label over each dot in the scatter plot\\nfor i in range(0, len(words)):\\n    ax.annotate(words[i], (embeddedWords[i, col1], embeddedWords[i, col2]))\\n\\n\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# geocode an address to lat-lng\\naddress = '704 S Alvarado St, Los Angeles, California'\\nlatlng = ox.geocode(address)\\nlatlng\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n1b: Geocoding addresses to lat-lng\\nYou can geocode addresses as well with OpenStreetMap, but it can be a little hit-or-miss compared to the data coverage of commercial closed-source services.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Before we show any results we configure we further configure the graphic, by changing the appearance of the simulated lines. We can obtain line objects from any graphics instance with the result_lines property:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nsim_graphics.result_lines\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"A présent la base df_pocket est nettoyée et prête à être utilisée pour les analyses de textes. \\nAnalyse des données textuelles - TD-IDF, similarité cosine et n-grams\\nLe calcul tf-idf (term frequency–inverse document frequency) permet de calculer un score de proximité entre un terme de recherche et un document (c'est ce que font les moteurs de recherche). \\nLa partie tf calcule une fonction croissante de la fréquence du terme de recherche dans le document à l'étude, la partie idf calcule une fonction inversement proportionnelle à la fréquence du terme dans l'ensemble des documents (ou corpus). \\nLe score total, obtenu en multipliant les deux composantes, permet ainsi de donner un score d'autant plus élevé que le terme est surréprésenté dans un document (par rapport à l'ensemble des documents). Il existe plusieurs fonctions, qui pénalisent plus ou moins les documents longs, ou qui sont plus ou moins smooth.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ncorpus = { \\n 'a' : \\\"Mr. Green killed Colonel Mustard in the study with the candlestick. \\\\\\nMr. Green is not a very nice fellow.\\\",\\n 'b' : \\\"Professor Plum has a green plant in his study.\\\",\\n 'c' : \\\"Miss Scarlett watered Professor Plum's green plant while he was away \\\\\\nfrom his office last week.\\\"\\n}\\nterms = {\\n 'a' : [ i.lower() for i in corpus['a'].split() ],\\n 'b' : [ i.lower() for i in corpus['b'].split() ],\\n 'c' : [ i.lower() for i in corpus['c'].split() ]\\n }\\n\\nfrom math import log\\n\\nQUERY_TERMS = ['mr.', 'green']\\n\\ndef tf(term, doc, normalize=True):\\n    doc = doc.lower().split()\\n    if normalize:\\n        return doc.count(term.lower()) \\/ float(len(doc))\\n    else:\\n        return doc.count(term.lower()) \\/ 1.0\\n\\n\\ndef idf(term, corpus):\\n    num_texts_with_term = len([True for text in corpus if term.lower() \\\\\\n                              in text.lower().split()])\\n    try:\\n        return 1.0 + log(float(len(corpus)) \\/ num_texts_with_term)\\n    except ZeroDivisionError:\\n        return 1.0\\n    \\ndef tf_idf(term, doc, corpus):\\n    return tf(term, doc) * idf(term, corpus)\\n\\nfor (k, v) in sorted(corpus.items()):\\n    print(k, ':', v)\\nprint('\\\\n')\\n\\nquery_scores = {'a': 0, 'b': 0, 'c': 0}\\nfor term in [t.lower() for t in QUERY_TERMS]:\\n    for doc in sorted(corpus):\\n        print('TF({}): {}'.format(doc, term), tf(term, corpus[doc]))\\n    print('IDF: {}'.format(term, ), idf(term, corpus.values()))\\n    print('\\\\n')\\n    for doc in sorted(corpus):\\n        score = tf_idf(term, corpus[doc], corpus.values())\\n        print('TF-IDF({}): {}'.format(doc, term), score)\\n        query_scores[doc] += score\\n    print('\\\\n')\\n\\nprint(\\\"Score TF-IDF total pour le terme '{}'\\\".format(' '.join(QUERY_TERMS), ))\\nfor (doc, score) in sorted(query_scores.items()):\\n    print(doc, score)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"#read json files\\nwith open('pageviews_desktop_201507-201709.json','r') as f:\\n    data_1 = json.load(f)\\nwith open('pageviews_mobile-app_201507-201709.json','r') as f:\\n    data_2 = json.load(f)\\nwith open('pageviews_mobile-web_201507-201709.json','r') as f:\\n    data_3= json.load(f)\\nwith open('pagecounts_desktop-site_200801-201607.json','r') as f:\\n    data_4 = json.load(f)\\nwith open('pagecounts_mobile-site_200801-201607.json','r') as f:\\n    data_5 = json.load(f)\\n    \\n\\n#load json in datapfram\\ndf_1 = pd.DataFrame(data_1['items'])\\ndf_2 = pd.DataFrame(data_2['items'])\\ndf_3 = pd.DataFrame(data_3['items'])\\ndf_4 = pd.DataFrame(data_4['items'])\\ndf_5 = pd.DataFrame(data_5['items'])\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nStep 2: Data Processing\\nWe need to do somt proccessing on these json file data inorder to analysis. I conbine monthly mobile-app and monthly mobile-web to total mobile for pageviews.\\nFirst, read the json file sepreatedly\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Lectures\\/elegent_exception_handling\\/Exceptions Handling.ipynb\\\".\\nThe first task is:\\nWe Can Proud of Ourselves 💃\\n\\n\\nImplemented restaurant recommendation 💪\\n\\n\\nClean code 💄\\n\\n\\n<img src=\\\"https:\\/\\/github.com\\/eyaltrabelsi\\/my-notebooks\\/raw\\/master\\/Lectures\\/unicorn_rainbow.png\\\" width=\\\"400\\\"\\/>\\nWhy Exception Handling? 🤨\\n\\n\\nHardware can fail 🌲\\n\\n\\nSoftware often fail 🚪\\n\\n\\nHow complex systems fail 🧩\\n\\n\\n<img src=\\\"https:\\/\\/github.com\\/eyaltrabelsi\\/my-notebooks\\/raw\\/master\\/Lectures\\/elegent_exception_handling\\/unicorn.png\\\" width=\\\"400\\\"\\/>\\nUnexceptable 😡\\nLesson 1: We want to build a fault tolerant system.\\nTypes of errors\\n\\nerror that can be detected at compile time\\nerrors that can be deteled at run time\\nerrors that can be infered\\nreproducieable erros\\nnon reproduceable errors\\n\\nWe want our code to be safe 👷\\nException Handling to the Rescue 👨‍🚒\\n\\n\\nDetect errors 🕵\\n\\n\\nDo something about them 🔒\\n\\n\\nNaive Approach 👶\\n\\n\\nLog all exceptions 📝\\n\\n\\nIgnore all exceptions 🙈\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef get_restaurant_recommendation(path):\\n    try:\\n        user = get_user(path)\\n        candidates = get_relevant_restaurants(user)\\n        pick_best_restaurants(candidates)\\n    except BaseException:\\n        logging.error(\\\"VERY UNINFORMATIVE INFORMATION\\\")\\n        raise BaseException(\\\"VERY UNINFORMATIVE INFORMATION\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Read drinks.csv (in the 'drinks_data' folder) into a DataFrame called 'drinks'\\n\\n# Print the first 10 rows\\n\\n# Examine the data types of all columns\\n\\n# Print the 'beer_servings' Series\\n\\n# Calculate the average 'beer_servings' for the entire dataset\\n\\n# Print all columns, but only show rows where the country is in Europe\\n\\n# Calculate the average 'beer_servings' for all of Europe\\n\\n# Only show European countries with 'wine_servings' greater than 300\\n\\n# Determine which 10 countries have the highest 'total_litres_of_pure_alcohol'\\n\\n# Determine which country has the highest value for 'beer_servings'\\n\\n# Count the number of occurrences of each 'continent' value and see if it looks correct\\n\\n# Determine which countries do not have continent designations\\n\\n# Determine the number of countries per continent. Does it look right?\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nExercise: Working with the Drinks Data\\n(Be on the lookout for a curveball question)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"1-Osnove_programiranja.ipynb\\\".\\nThe first task is:\\nOsim ovom metodom, elemente liste moguće je brisati putem naredbe del i indeksa elementa:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nlista5=['banana',5,98.95,'tekst',5]\\ndel lista5[-1]\\nprint lista5\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"<div class=\\\"text-warning\\\">\\n    <h3>Some methods not work in a remote experiment<\\/h3>\\n<\\/div>\\n\\n\\nsession_config()\\nbot_data()\\n\\nRaises an NotImplementedError when are called.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nremote.bot_data(\\\"matching_pennies\\\", 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 \\\"04 Regression & Comparing Models.ipynb\\\".\\nThe first task is:\\nNote: the MSE goes down because of the log10 transform. However, that's exactly what we would have expected by definition.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmean_squared_error(preds, Y_test)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"ImportAppleHealthXML.ipynb\\\".\\nThe first task is:\\nDownload the file from Google Drive\\nEnsure that the file downloaded is the latest file generated\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfor file1 in file_list:\\n        if file1['id'] == selection_id:\\n            print('Downloading this file: %s, id: %s createDate: %s' % (file1['title'], file1['id'], file1['createdDate']))\\n            file1.GetContentFile(\\\"healthextract\\/export.zip\\\")\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# sklearn.datasets.make_sparse_uncorrelated\\n\\nX, y = sklearn.datasets.make_blobs(n_samples=30, centers=3, n_features=7, random_state=0)\\nprint(X.shape)\\nsns.heatmap(X, robust=True, square=False, yticklabels=True, xticklabels=True, cbar=True)\\nplt.show()\\n\\n# D = pairwise_distances(X, metric='euclidean', n_jobs=-1)\\n# sns.heatmap(D, robust=True, square=True, yticklabels=True, xticklabels=True, cbar=True)\\n# plt.show()\\n\\n# plt.hist(np.hstack(D), 20, facecolor='orange', alpha=0.75)\\n# plt.xlabel('Pairwise distances')\\n# plt.ylabel('Frequency')\\n# plt.grid(True)\\n# plt.show()\\n\\ndef scatterplot_2D(R, title, labels=None):\\n    \\\"\\\"\\\" Helper function to plot data points in 2D\\n        Requires (N, 2) numpy array shape\\n    \\\"\\\"\\\"\\n    assert(R.shape[1] == 2)\\n    # class labels are turned into colors\\n    if labels is None:\\n        c = 'black'\\n    else:\\n        color_scale = np.linspace(0, 1, len(set(labels)))\\n        c = [plt.cm.Set1(color_scale[i]) for i in labels]\\n\\n    fig = plt.figure()\\n    ax = fig.add_subplot(111)\\n    ax.patch.set_facecolor('white')\\n    ax.scatter(R[...,0], R[...,1], color=c)\\n    ax.axis('square')\\n    ax.set_xlabel('R1')\\n    ax.set_ylabel('R2')\\n    fig.suptitle(title)\\n    plt.show()\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFeatures and high-dimensional spaces\\nMany types of data can contain a large number of variables (features in terms of ML). Dimensionality of the problem is essentially equal to the number of features as data could be interpreted as points in a high-dimensional space. Example of a 30D benign-vs-malignant classification problem: http:\\/\\/scikit-learn.org\\/stable\\/modules\\/generated\\/sklearn.datasets.load_breast_cancer.html#sklearn.datasets.load_breast_cancer. Whether this is individual pixels in images, transcripts or genes\\/proteins in -omics data or word occurrences in text data a large number of features poses several challenges. \\nIn particular, visualizing more than three dimensions is difficult complicating our data analysis and exploration. Moreover, in machine learning models a large number of features translates directly into a large number of free parameters. Thus, there is a risk of overfitting the models to the data, and having a model that does not generalize to new observations. An obvious solution to address these challenges would be reducing the number of features and, consequantly, the dimensionality of the feature space. There are two approaches:\\n\\nTransform the data into a lower dimensional space (dimensionality reduction)\\nFeature elimination (discard less important features) or feature selection (select more important features)\\n\\n1. Dimensionality reduction\\nThere are three fundamentally different ways of transforming the feature space:\\n* Decomposition -- a set of frameworks for finding optimal linear projections of data onto lower dimensional space without losing much information about the structure within the data. These linear frameworks include Principal Component Analysis (PCA), Independent Component Analysis (ICA), Linear Discriminant Analysis (LDA), Factor Analysis (FA), Dictionary Learning, Non-negative matrix factorization (NMF), etc.\\n\\nManifold Learning -- optimal for finding non-linear structure in data, however it may not be able to apply transformation to new data points. Typically it is an...\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Introduction_to_Pandas.ipynb\\\".\\nThe first task is:\\nOperations can be applied to Series without losing the data structure.\\nUse bool array to filter Series\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfruit > 50\\n\\nfruit[fruit > 50]\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"ApacheMXNet\\/linear_regression_from_scratch.ipynb\\\".\\nThe first task is:\\nData iterators\\nOnce we start working with neural networks, we’re going to need to iterate through our data points quickly.\\nWe’ll also want to be able to grab batches of k data points at a time, to shuffle our data.\\nIn MXNet, data iterators give us a nice set of utilities for fetching and manipulating data.\\nIn particular, we’ll work with the simple DataLoader class, that provides an intuitive way to use an ArrayDataset for training models.\\nWe can load X and y into an ArrayDataset, by calling gluon.data.ArrayDataset(X, y).\\nIt’s ok for X to be a multi-dimensional input array (say, of images) and y to be just a one-dimensional array of labels.\\nThe one requirement is that they have equal lengths along the first axis, i.e., len(X) == len(y).  \\nGiven an ArrayDataset, we can create a DataLoader which will grab random batches of data from an ArrayDataset.\\nWe’ll want to specify two arguments.\\nFirst, we’ll need to say the batch_size, i.e., how many examples we want to grab at a time.\\nSecond, we’ll want to specify whether or not to shuffle the data between iterations through the dataset.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nbatch_size = 4\\ntrain_data = gluon.data.DataLoader(gluon.data.ArrayDataset(X, y),\\n                                  batch_size=batch_size, shuffle=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 \\\"02_data_representation\\/embeddings.ipynb\\\".\\nThe first task is:\\nFrom this and the tokenizer we can extract the VOCAB_SIZE, DATASET_SIZE and MAX_LEN.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nVOCAB_SIZE = len(tokenizer.index_word)\\nVOCAB_SIZE\\n\\nDATASET_SIZE = tokenizer.document_count\\nDATASET_SIZE\\n\\nMAX_LEN = max(len(sequence) for sequence in integerized_titles)\\nMAX_LEN\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Pattern shape\\nncols = 3\\nnrows = 2\\n\\n# Coordinates of the LCOS center in the pattern space\\ncenter_x = 100\\ncenter_y = 200\\n\\n# Rotation of the LCOS grid versus the pattern space\\nrotation = 20\\n\\n# Pitch for the multi-spot pattern\\npitch_x = 80\\npitch_y = 60\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nPattern parameters:\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Aquifer properties\\nkD = 900 # m2\\/d\\nS = 0.25 # [-]\\n\\n# Only for semi-confined (Hantush) flow we need the resistance of the overlying layer\\nc  = 300 # d\\nlamb = np.sqrt(kD * c) # characteristic length of semi-confined system.\\n\\n# Parameters specifying the case\\nQ = 1200 # m3\\/d\\nr = 350 # m\\nt = 1.2 # d\\n\\n# compute u from the ordinary parameters\\nu = r**2 * S \\/ (4 * kD * t)\\n\\n# compute the drawdown using function exp1 (=exponential integral)\\ns = Q\\/(4 * np.pi * kD) * exp1(u)\\n\\nprint('Drawdown s = {:.4g} m'.format(s))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nSimple example, just compute the drawdown given $kD$, $S$, $r$ and $t$ using exp1(..)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Day_00\\/02_Strings_and_FileIO\\/00 Strings in Python.ipynb\\\".\\nThe first task is:\\nChanging\\nCan you write Python code for it?\\n\",\"targets\":\"\\nsome_kaiju = 'Godzilla, Space Godzilla, Mechagodzilla'\\nprint re.sub('Godzilla', 'Gamera', some_kaiju)\\nprint re.sub('(?i)Godzilla', 'Gamera', some_kaiju)\",\"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 1 - Unit 2.2 DataFrame.ipynb\\\".\\nThe first task is:\\nQ6: How many countries participated in at least 25 Olympic games (100 years)? Return an integer.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nlen(og.query(\\\"Games >= 25\\\").loc[:, \\\"Country\\\"])\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Cluster subsample visualization\\n\",\"targets\":\"x = features['serum_cholesterol_mg_per_dl']\\ny = features['resting_blood_pressure']\\n\\ntrace = [go.Scatter(\\n    x = x,\\n    y = y,\\n    name = 'data',\\n    mode = 'markers',\\n    hoverinfo = 'text',\\n    text = ['x: %s<br>y: %s' % (x_i, y_i) for x_i, y_i in zip(x, y)]\\n)]\\n\\nlayout = go.Layout(\\n    xaxis = dict({'title': xlab}),\\n    yaxis = dict({'title': ylab})\\n)\\n\\nfig = go.Figure(data=trace, layout=layout)\\niplot(fig, layout)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"1.2\\n12x12 matrix whose columns sum to 1, whose diagonals are 0 and off-diagonals are strictly positive. Use np.round(mat_name,2) to only have two decimals when printing.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nimport numpy as np\\n\\ns = 12\\nm = np.ones( (s,s) )\\nm[np.diag_indices(s)] = 0\\nfor i in range(s):\\n    m[:,i] \\/= np.sum(m[:,i])\\nprint(np.round(m,2))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# http:\\/\\/scikit-learn.org\\/stable\\/modules\\/clustering.html\\n\\ndataset_array = df.values\\nprint(dataset_array.dtype)  # kmeans needs to be homogeneous data type (here, float64)\\nprint(dataset_array)\\n\\n# do I need to normalize\\n# sklearn.preprocessing.StandardScaler\\nfrom sklearn import preprocessing\\n\\n# http:\\/\\/scikit-learn.org\\/stable\\/modules\\/preprocessing.html\\n# first load scaler and train on given data set\\nscaler = preprocessing.StandardScaler().fit(df)\\n\\nscaler.mean_\\n\\nscaler.scale_\\n\\nt0 = dt.datetime.utcnow()\\n\\n# actually do normalization; can be reused for eg a training set\\ndf_scaled = pandas.DataFrame(scaler.transform(df))\\n\\nprint('... finished in {}'.format(dt.datetime.utcnow() - t0))\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nScale\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Figure 3\\nRMSE_spline_rses = np.sqrt(mean_squared_error(ll_2018.water_predicted, ll_2018.water))\\nRMSE_poly_rses = np.sqrt(mean_squared_error(dg_2018.water_predicted, dg_2018.water))\\n\\nprint('Dataset 2018 RSES')\\nprint('Standard deviation with the method of LL 2012 is :'+str(np.round(RMSE_spline_rses,2)))\\nprint('Standard deviation with the method of DG 2017 is :'+str(np.round(RMSE_poly_rses,2)))\\n\\nplt.figure(figsize=(3.25, 6.5))\\nplt.subplot(2,1,1)\\n\\nplt.plot(ll_2018.water_predicted,ll_2018.water,\\\"o\\\",mfc=\\\"none\\\",mec=\\\"k\\\",label=\\\"Iron-free\\\")\\nplt.plot(ll_2018.water_predicted[np.where(data_liste_rses[\\\"FeO\\\"]>0)],data_liste_rses[\\\"Water, wt%\\\"].loc[data_liste_rses[\\\"FeO\\\"]>0],\\\"o\\\",mfc=\\\"k\\\",mec=\\\"k\\\",label=\\\"Iron-bearing\\\")\\n\\nplt.plot([0,8.5],[0,8.5],\\\"k--\\\",alpha=0.5)\\nplt.xlabel(r\\\"Raman [H$_2$O] \\/ wt $\\\\%$\\\")\\nplt.ylabel(r\\\"Reference [H$_2$O] \\/ wt $\\\\%$\\\")\\nplt.title(\\\"A) LL2012 method\\\")\\nplt.legend()\\n\\nplt.subplot(2,1,2)\\nplt.plot(dg_2018.water_predicted,data_liste_rses[\\\"Water, wt%\\\"],\\\"s\\\",mfc=\\\"none\\\",mec=\\\"k\\\",label=\\\"Iron-free\\\")\\nplt.plot(dg_2018.water_predicted[np.where(data_liste_rses[\\\"FeO\\\"]>0)],data_liste_rses[\\\"Water, wt%\\\"].loc[data_liste_rses[\\\"FeO\\\"]>0],\\\"s\\\",mfc=\\\"k\\\",mec=\\\"k\\\",label=\\\"Iron-bearing\\\")\\n\\nplt.plot([0,8.5],[0,8.5],\\\"k--\\\",alpha=0.5)\\n\\nplt.xlabel(r\\\"Raman [H$_2$O] \\/ wt $\\\\%$\\\")\\nplt.ylabel(r\\\"Reference [H$_2$O] \\/ wt $\\\\%$\\\")\\nplt.title(\\\"B) DG2017 method\\\")\\n\\nplt.tight_layout()\\n\\nplt.savefig(\\\".\\/Figure3.pdf\\\")\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nFigure 3\\nComparison of the known water content of basalts and Ca aluminosilicate glass standards with the Raman calculated values following the A) LL2012 and B) DG2017 protocols.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"A Beginners Guide to Python\\/20. Functions & Namespaces.ipynb\\\".\\nThe first task is:\\nWhy does Python do this?\\nThe main advantage to variable scope and namespaces is that as your code becomes progressively larger you don't have to keep on coming up with new names for objects. It is easy to imagine how constantly coming up with new names would, after a while adversely affect readability and make coding a lot slower (because with so many names you are going to continually forget which one you need to use). \\nThe other advantage is that if functions cannot change the content of another function (without your express blessing) then the chance for ugly bugs and\\/or nasty side-effects to occur is reduced.  \\nFinally, I'd like to point out that its not just functions that their own scope. In the code snippet below I have defined three list-comprehensions (not covered in this course) and printed them out. What I want you to focus on is how I used and reused the letter 'i' as a variable name several times, and that is okay because 'i' is defined in context ('scope') of each individual list comprehension. These means that all these 'i's' are completely separate from each other, and moreover, 'i' is not defined in the 'main program', which explains the NameError.\\nCan you write Python code for it?\\n\",\"targets\":\"\\na = [i for i in range(10)]\\nb = [i for i in range(20)]\\nc = [i for i in \\\"abcde\\\"]\\n\\nprint(a, b, c, sep=\\\"\\\\n\\\")\\nprint(i)\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Assignment1.ipynb\\\".\\nThe first task is:\\nLet's rename the column names:\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndf.columns = [\\\"ID\\\",\\\"Clump_Thickness\\\",\\\"Size_Uniformity\\\",\\\"Shape_Uniformity\\\",\\\"Marginal_Adhesion\\\",\\\"Epithelial_Size\\\",\\\"Bare_Nucleoli\\\",\\\"Bland_Chromatin\\\",\\\"Normal_Nucleoli\\\",\\\"Mitoses\\\",\\\"Class\\\"]\\n\\n# Print the new header names:\\ndf.columns\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# define the integrand \\nf_height_of_peak_weighted = seir.height_of_peak_weighted(meanmax)\\n\\n# define integral bounds\\nlb = 1. # lower integral bound\\nub = 80. # upper integral bound\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\n<a id='section-task1'><\\/a>\\nTask 1: Height of peak of infection\\nThe height of the peak is the expected maximal number of simultaneously infected individuals \\n$$\\n\\\\mathbb{E}a\\\\left[\\\\max_t N_I(t, \\\\alpha)\\\\right] =\\\\int{\\\\Omega}\\\\max_t N_I(t, \\\\alpha)p(\\\\alpha)\\\\mathrm{d}\\\\alpha.\\n$$\\nWe use the Bayesian quadrature package of Emukit to emulate the integrand $\\\\max_tN_I(t, \\\\alpha)p(\\\\alpha)$. \\nDefine user function $\\\\max_t N_I(t, \\\\alpha)p(\\\\alpha)$ and integral bounds\\nWe call the integrand $\\\\max_t N_I(t, \\\\alpha)p(\\\\alpha)$ f_height_of_peak_weighted  since it computes the height of the infection peak weighted with the prior on $\\\\alpha$. One call of f_height_of_peak_weighted will run num_gil Gillespie runs. The integral bounds have units $\\\\alpha$, i.e., units of infection time divided by recovery time; they define the domain $\\\\Omega = [lower_bounds, upper_bound]$. We choose 80 to be the upper bound since we assume that the infection rate will not be larger than 80 times the recovery rate.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Correlation metrics\\nSpearman correlation\\nSpearman correlation`\\nanswers the simple question, every time $x$ increases, does $y$ increase also? If yes, then spearman correlation = 1.\\nMathematically speaking, Spearman tells you whether $x$ and $y$ increase monotonically together (but not necessarily linearly!!)\\n\\nPearson correlation\\nPearson Correlation answers the question, every time my $x$ decreases by some amount $a$, does $y$ decrease by an amount proportional to that, say $10a$ or $0.5a$, and is this amount constant?\\n$\\\\rho_{x,y} = \\\\frac{\\\\mathrm{cov}(\\\\vec{x}, \\\\vec{y})}{\\\\sigma_x, \\\\sigma_y}$\\nMathematically speaking, pearson tells you whether $x$ and $y$ are linear to each other.\\n\\nSpearman vs Pearson\\nSpearman's correlation is related to Pearson because Spearman \\nSpearman correlation = Pearson correlation on the ranks of the data.\\nAnscombe's quartet\\nAnscombe's quartet is a group of four datasets that have nearly identical statistical properties that we'll use for exploring distance and correlation metrics.\\n\",\"targets\":\"# Read the file - notice it is a URL. pandas can read either URLs or files on your computer\\nanscombe = pd.read_csv(\\\"https:\\/\\/github.com\\/mwaskom\\/seaborn-data\\/raw\\/master\\/anscombe.csv\\\")\\n\\n# Say the variable name with no arguments to look at the data\\nanscombe\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"markdowncode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"As you can imagine, this can be handy when we have a large number of layers for which the actual names are not that meaningful. It also improves readability:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nclass MyCustomModule(nn.Module):\\n    def __init__(self, n_inputs, n_hidden, n_output_classes):\\n        super(MyCustomModule, self).__init__()\\n        self.p_keep = 0.7\\n        self.network = nn.Sequential(\\n            nn.Linear(n_inputs, n_hidden),\\n            nn.ReLU(),\\n            nn.Linear(n_hidden, 2*n_hidden),\\n            nn.ReLU(),\\n            nn.Linear(2*n_hidden, n_output_classes),\\n            # dropout argument is probability of dropping\\n            nn.Dropout(1 - self.p_keep),\\n            # applies softmax in the data dimension\\n            nn.Softmax(dim=1)\\n        )\\n\\n    def forward(self, x):\\n        y = self.network(x)\\n        return y\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# Create a pool of workers equaling cores on the machine\\npool = ThreadPool() \\n\\n%%time\\n\\n# Apply (map) some_function to the data using the pool of workers\\nresults = pool.map(some_function, data)\\n\\n# Close the pool\\npool.close() \\n\\n# Combine the results of the workers\\npool.join() \\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nParallelism Approach\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"A chance to speed up training and get bonus score\\n\\nTry predicting next token probas at ALL ticks (like in the seminar part)\\nmuch more objectives, much better gradients\\nYou may want to zero-out loss for first several iterations\\n\\nThe New World Order\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\nseed = u\\\"Каждый человек должен\\\" #if you are using non-russian text corpora, use seed in it's language instead\\nsampling_fun = proportional_sample_fun\\nresult_length = 300\\n\\ngenerate_sample(sampling_fun,seed,result_length)\\n\\n\\nseed = u\\\"В случае неповиновения\\\"\\nsampling_fun = proportional_sample_fun\\nresult_length = 300\\n\\ngenerate_sample(sampling_fun,seed,result_length)\\n\\n\\nAnd so on at your will\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Coursera\\/Machine-learning-data-analysis\\/Course 3\\/Week_04\\/edit_CookingLDA_PA.ipynb\\\".\\nThe first task is:\\nДля такого большого количества классов это неплохая точность. Вы можете попроовать обучать RandomForest на исходной матрице частот слов, имеющей значительно большую размерность, и увидеть, что accuracy увеличивается на 10–15%. Таким образом, LDA собрал не всю, но достаточно большую часть информации из выборки, в матрице низкого ранга.\\nLDA — вероятностная модель\\nМатричное разложение, использующееся в LDA, интерпретируется как следующий процесс генерации документов.\\nДля документа $d$ длины $n_d$:\\n1. Из априорного распределения Дирихле с параметром alpha сгенерировать распределение над множеством тем: $\\\\theta_d \\\\sim Dirichlet(\\\\alpha)$\\n1. Для каждого слова $w = 1, \\\\dots, n_d$:\\n    1. Сгенерировать тему из дискретного распределения $t \\\\sim \\\\theta_{d}$\\n    1. Сгенерировать слово из дискретного распределения $w \\\\sim \\\\phi_{t}$.\\nПодробнее об этом в Википедии.\\nВ контексте нашей задачи получается, что, используя данный генеративный процесс, можно создавать новые рецепты. Вы можете передать в функцию модель и число ингредиентов и сгенерировать рецепт :)\\nCan you write Python code for it?\\n\",\"targets\":\"\\ndef generate_recipe(model, num_ingredients):\\n    theta = np.random.dirichlet(model.alpha)\\n    for i in range(num_ingredients):\\n        t = np.random.choice(np.arange(model.num_topics), p=theta)\\n        topic = model.show_topic(t, topn=model.num_terms)\\n        topic_distr = [x[1] for x in topic]\\n        terms = [x[0] for x in topic]\\n        w = np.random.choice(terms, p=topic_distr)\\n        print(w)\\n\\ngenerate_recipe(lda2, 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 \\\"PNC_01Basics.ipynb\\\".\\nThe first task is:\\nozone[0, :, 2, 3] * averagekernelm\\nCan you write Python code for it?\\n\",\"targets\":\"\\nozone[0, :, 2, 3] * averagekernelm.T\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Addition, multiplication, and subtraction\\nSimilar grids can be added, multiplied and subtracted using standard python operators. It is easily verified that the following sequence of operations return the same rotated grid as above:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\ngrid_new = (2 * grid_l5m0_rot + grid_l5m2**2 - grid_l5m2 * grid_l5m2) \\/ 2.0\\ngrid_new.plot()\\n\\ncoeffs = grid_new.expand()\\nfig, ax = coeffs.plot_spectrum()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# 복원된 모델을 평가합니다\\nloss, acc = new_model.evaluate(test_images,  test_labels, verbose=2)\\nprint('복원된 모델의 정확도: {:5.2f}%'.format(100*acc))\\n\\nprint(new_model.predict(test_images).shape)\\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\":\"I am working on the file \\\"Loan_payment_feature_engineering.ipynb\\\".\\nThe first task is:\\nAll these payments seem to have flat months indeed! As we assume that loans are payed monthly, the flat lines on the map appear to be missed payments. As order_info provides us with the heigth of every montly payment, we can plot the difference between the money ordered and eventually paid.\\nAlso, all payments occur on the 12th of the month. Many customers who sign the contract of the loan before the 12th, therefore providing a missing payment in the data which may be artificial. We assume that loan payments start the next month therefore we bump the date by 12 days if the day in the month is before the 12th, removing our missed payments.\\nCan you write Python code for it?\\n\",\"targets\":\"\\nfrom datetime import datetime\\npayment_diff = transaction_scope.copy()\\nfor acct in scope:\\n    loan_start = loan_info[loan_info['account_id']==acct]['date'].unique()[0]\\n    loan_date = datetime.strptime(loan_start, '%Y-%m-%d')\\n    if loan_date.day < 12:\\n        loan_date = datetime(loan_date.year, loan_date.month, loan_date.day + 12)\\n    loan_start = loan_date.strftime('%Y-%m-%d')\\n    loan_order = loan_info[loan_info['account_id']==acct]['payments'].unique()[0]\\n    payment_diff.loc[payment_diff.index > loan_start, acct] = payment_diff.loc[payment_diff.index > loan_start,acct] - loan_order\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"(B) Counting characters. Is it faster to use the built-in function str.count() or to loop through a string and count characters manually? Compare the two by counting all the A's in all the sequences in fake.fasta using each method and comparing how long they take to run. \\n(You do not need to output the counts)\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n# Method 1 (Manual counting)\\nseqDict = my_utils.read_fasta(\\\"fake.fasta\\\")\\n\\nstart = time.time()\\n\\nfor seqID in seqDict:\\n    seq = seqDict[seqID]\\n    count = 0\\n    for char in seq:\\n        if char == \\\"A\\\":\\n            count += 1\\n            \\nend = time.time()\\nprint end - start\\n\\n# Method 2 (.count())\\nseqDict = my_utils.read_fasta(\\\"fake.fasta\\\")\\n\\nstart = time.time()\\n\\nfor seqID in seqDict:\\n    seq = seqDict[seqID]\\n    count = seq.count(\\\"A\\\")\\n            \\nend = time.time()\\nprint end - start\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"Above, we created a new transform primitive that can be used with Deep Feature Synthesis by deriving a new primitive class using TransformPrimitive as a base and overriding get_function to return a function that calculates the feature. Additionally, we set the input data types that the primitive applies to and the return data type. Input and return data types are defined using a Woodwork ColumnSchema. A full guide on Woodwork logical types and semantic tags can be found in the Woodwork Understanding Types and Tags guide.\\nSimilarly, we can make a new aggregation primitive using AggregationPrimitive.\\n\",\"targets\":\"class Maximum(AggregationPrimitive):\\n    name = 'maximum'\\n    input_types = [ColumnSchema(semantic_tags={'numeric'})]\\n    return_type = ColumnSchema(semantic_tags={'numeric'})\\n\\n    def get_function(self):\\n        def maximum(column):\\n            return max(column)\\n\\n        return 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 \\\"NEU\\/Tejas_Bawaskar _DL\\/Deep Network Visualization.ipynb\\\".\\nThe first task is:\\nVisualizing the fifth convnet\\/decoded\\/output layer_5 with sample test image\\nCan you write Python code for it?\\n\",\"targets\":\"\\ni = 1\\nx = x_test[i:i+1]\\ncheck = np.squeeze(np.squeeze(np.array(convout5_f(x)),0),0)\\ncheck.shape\\n\\n#Plotting conv_5\\n\\ntemp = x[0,:,:,:]\\nfig, axes = plt.subplots(1, 1, figsize=(3, 3))\\nplt.imshow(temp)\\nplt.show()\\n\\n\\nk = 0\\nwhile k < check.shape[2]:\\n    #plt.figure()\\n    #plt.subplot(231 + i)\\n    fig, axes = plt.subplots(2, 4, figsize=(5, 5))\\n    for i in range(2):\\n        for j in range(4):\\n            axes[i,j].imshow(check[:,:,k])\\n            k += 1\\n    #axes[0, 0].imshow(R, cmap='jet')\\n    #plt.imshow(check[:,:,i])\\n\\nplt.show()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"# look at unique company names in rounds df\\n# note that the column name in rounds file is different (company_permalink)\\nlen(rounds.company_permalink.unique())\\n\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nThus, there are 66368 unique companies in the table and permalink is the unique primary key. Each row represents a unique company.\\nLet's now check whether all of these 66368 companies are present in the rounds file, and if some extra ones are present.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"!cd 06-regsort-gpu\\/hybrid ; nvprof -s --profile-child-processes  .\\/run.sh\\nGiven the above code, generate some markdown instructions for it.\\n\",\"targets\":\"\\nLocal load and store transactions should have been reduced to zero.\\nThe display of kernel time actually includes some memory transfer and synchronization. The real execution time is returned by the profiler when run in summary mode.\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"genmarkdown\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"DL0110EN\\/5.1.1dropoutPredictin.ipynb\\\".\\nThe first task is:\\nCreate two model objects: model had no dropout and model_drop has a dropout probability of 0.5:\\nCan you write Python code for it?\\n\",\"targets\":\"\\nmodel=Net(2,300,2)\\nmodel_drop=Net(2,300,2,p=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 \\\"Data Wrangling with Python.ipynb\\\".\\nThe first task is:\\nBonus Round: Questions we can ask of this data\\nNow, you can start asking questions of this data. What are some interesting questions that this data might answer for us, and how would do that?\\n\\nWhich congressional districts get the most funding?\\nWhich agencies get the most funding in my state?\\n[With the help of additional data] Which congressional committees do congress folk sit on and is there a coorelation between the committees they sit on and the agencies or contractors that are getting contracts?\\nHow removed is the location of the contractor vs the place where the work is being performed?\\nWhat interesting things might there be in the walshhealyact, servicecontractact, davisbaconact, and clingercohenact columns?\\nWhat is the distribution of size of vendor to number of contracts and also to the number of contracting dollars? Is any vendor an outlier?\\nWhat are the reasons for non-competed contracts?\\nWhat percentage of contracts are in each of these categories, and are the numbers reflective of the population as a whole:\\nissbacertifiedsmalldisadvantagedbusiness\\nwomenownedflag\\nveteranownedflag\\nminorityownedbusinessflag\\ntribalgovernmentflag\\nishispanicservicinginstitution\\niswomenownedsmallbusiness\\nisecondisadvwomenownedsmallbusiness\\nisjointventurewomenownedsmallbusiness\\nisjointventureecondisadvwomenownedsmallbusiness\\n\\n\\n\\nWhat other kinds of questions can we ask?\\nCan you write Python code for it?\\n\",\"targets\":\"\\nprint table\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"Aside: If you ever need true decimal storage with no loss of precision, turn to the Decimal package. Just be warned it will come at a price:\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\na_native = 1.0\\nb_native = 2.0\\n\\na_decimal = Decimal ('1.0')\\nb_decimal = Decimal ('2.0')\\n\\n%timeit a_native + b_native\\n%timeit a_decimal + b_decimal\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"I am working on the file \\\"Check_bug_correction.ipynb\\\".\\nThe first task is:\\nThe same plot than before but using the new threshol\\nCan you write Python code for it?\\n\",\"targets\":\"\\n# Use new threshold for old data as well\\ncond_sel = ((merged['lr_5_old'] >= tnew) | (merged['lr_5_new'] >= tnew))\\ncond_nosel = ((merged['lr_5_old'] < tnew) & (merged['lr_5_new'] < tnew))\\ncond_change = ((merged['lr_5_old'] >= tnew) & (merged['lr_5_new'] < tnew))\\nplt.loglog(merged['lr_5_new'][cond_sel], (np.abs(diff_lr)\\/merged['lr_5_new']*100)[cond_sel], marker=\\\",\\\", ls=\\\"\\\", label=\\\"Selected\\\")\\nplt.loglog(merged['lr_5_new'][cond_nosel], (np.abs(diff_lr)\\/merged['lr_5_new']*100)[cond_nosel], marker=\\\",\\\", ls=\\\"\\\", label=\\\"Rejected\\\")\\nplt.loglog(merged['lr_5_new'][cond_change], (np.abs(diff_lr)\\/merged['lr_5_new']*100)[cond_change], marker=\\\"x\\\", ls=\\\"\\\", label=\\\"Changes\\\")\\nplt.xlabel(\\\"log LR (new)\\\")\\nplt.ylabel(\\\"log percent abs. LR diff\\\")\\nplt.legend()\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"taskcode\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"
"{\"inputs\":\"\\\"2.3) Spectral Clustering of the Microcircuit Network\\nIn this section we'll focus, as in notebook 2, on finding two clusters inside our network.\\nThe clusters will be computed in the following ways:\\n\\nusing the sign of the Fiedler vector.\\nusing the k-mean algorithm with k=2. \\n\\nNote For accuracy of the k-mean algorithm we had to delete 4 points in the embedding of the combinatorial Laplacian. These ponts are located far away from the 'core' of the embedding and couldn't give us a good partition of the network with the k-mean algorithm.\\\"\\nPlease write code following the instructions in jupyter notebook style.\\n\",\"targets\":\"\\n##Delete points too far away from the 'core' of the embedding of the combinatorial Laplacian\\nX=np.column_stack((x,y))\\nX1=np.array([w for w in X if np.abs(w[0])<0.02 and np.abs(w[1])<0.002])\\nx1 = X1[:,0]\\ny1 = X1[:,1]\\n##k-mean algorithm  (k=2) for the combinatorial Laplacian \\nkmeans = KMeans(n_clusters=2, init='random').fit(X1)\\nlab=kmeans.labels_\\n##K-mean algorithm for the normalized Laplacian\\nXnorm=np.column_stack((x_norm,y_norm))\\nkmeans = KMeans(n_clusters=2, init='random').fit(Xnorm)\\nlabnorm=kmeans.labels_\\n#db=DBSCAN(eps=0.0005, min_samples=9000).fit(Xnorm)\\n#labnorm=db.labels_\\n\\n##Function for creating labels\\ndef labelcreate(a,val=0):\\n  col=[]\\n  for i in range(N):\\n    if a[i]>val:\\n      col.append(1)\\n    else:\\n      col.append(-1)\\n  return col\\n\\nplt2dembeddings(x_norm,y_norm,x1,y1, col1=labnorm, col2=lab,colmap='PiYG',title1='Clustering using K-mean',title2='Clustering using K-mean')\\nsign=np.sign(evect_norm[:,1])\\nlabels_norm = [sign]\\nlabels = [np.sign(evect[:,1])]\\nplt2dembeddings(x_norm,y_norm,x,y, col1=labels_norm[0], col2=labels[0],colmap='Spectral',title1='Clustering using Fiedler vector',title2='Clustering using Fiedler vector')\\n\\n\\nfor i in range(len(lab)):\\n  if labnorm[i]==0:\\n    labnorm[i]=-1\\nerr=np.count_nonzero(labnorm - sign)\\nerr = min(err, N - err)\\nprint('The partition given by the K-mean algorithm and the sign of the Fiedler vector differ for {} points'.format(err))\",\"language\":\"jupyter-notebook\",\"split\":\"train\",\"template\":\"code\",\"dataset\":\"codeparrot\\/github-jupyter-text-code-pairs\",\"config\":null}\n"