Assignment 3: Cookie Pricing

CSci 39542: Introduction to Data Science¶

Department of Computer Science Hunter College, City University of New York Spring 2026

To get full credit for a program, the file must include in the opening comment:

• Your name, as it appears in your Gradescope registration.

• The email you are using for Gradescope.

• A list of any resources you used for the program. Include classmates and tutors that you worked with, along with any websites or tutorials that you used. If you used no resources (other than the class notes and textbooks), then you should include the line: “No resources used.”

Program 3: Cookie Pricing.¶

Due AoE, 31 March

Learning Objective: to build models with polynomial features, employ thresholds to decide model fitness, and use regularization techniques to better fit models.

Data Sources: St. Louis Federal Reserve Bank Online Data (FRED).

Available Libraries: pandas, numpy, scikit-learn, pickle, pytest, and core Python 3.6+. The available packages used for scikit-learn: sklearn.model_selection, sklearn.preprocessing, sklearn.linear_model, and sklearn.metrics.

Sample Datasets: fred_ccc.csv

Federal Reserve Economic Data (FRED)¶

This program builds models for economic data from St. Louis Federal Reserve Bank Economic Data (FRED), using polynomial features and regularization for economica data.

We will focus, on the average price of chocolate chip cookies and their ingredients, but it can be generalized for other price indices. The pipeline below is general enough to handle actual prices as well as changes over time and price indices. The first steps are importing the data and splitting it into training and testing sets. The training set is then used to determine the degree of the polynomial for the model, and once that is determined, regularization, with cross validation, is used to fit a model that can be validated with the testing data and used for predictions.

Start by downloading the data file:

1. Go to St. Louis Federal Reserve Bank Economic Data (FRED).

2. In the search window, type: Chocolate Chip Cookies.

3. Click on Average Price: Cookies, Chocolate Chip (Cost per Pound/453.6 Grams) in U.S. City Average. It’s index number is APU0000702421.

4. You should see a graph of the average price of cookies, like the image above.

5. Click on the red button: Edit Graph.

6. On the top of the side bar, click on ADD LINE.

7. Type in eggs into the search bar. Choose the average price index (APU0000708111). And click on Add data series.

8. Repeat the last two steps with butter (APU0000FS1101), chocolate (PCU3113513113517), flour (APU0000701111), and sugar (APU0000715211).

9. Click the X in the upper right corner to close the side bar menu.

10. Next, adjust dates so all indices are defined. Click on the 1980-01-01 and change it to 2018-04-01 (before which the butter index is not defined).

11. Click on DOWNLOAD and choose CSV and save the file to your working directory.

Preparing Data¶

Once you have downloaded some test data sets to your device, the next thing to do is format the data to be usable for analysis. The data from FRED is very clean, so, we will only need to split into training and testing sets. Add the following function to your Python program:

1. import_data(csv_file, names=None): This function takes two inputs:

• csv_file: the name of a CSV file time series data for commodities from FRED.

• names: a dictionary of names where the keys are the codes for commodity indices and the values are the name to be used for the column. The default value is None.

The data in the file is read into a DataFrame with the DATE column is dropped. If names is not None, then the remaining column names correspond to the values of the names dictionary. For example, if the csv_file contains the chocolate chip cookie data, then a possible corresponding dictionary is: names = {'APU0000702421' : 'CC Cookies', 'APU0000708111' : 'Eggs', 'APU0000FS1101' : 'Butter', 'PCU3113513113517' : 'Chocolate','APU0000701111' : 'Flour', 'APU0000715211' : 'Sugar'} . Any rows with non-numeric entries is dropped. You can replace non-numeric entries with NaN by converting to numeric and coercing errors (which will put in NaN if a entry is not numeric):

and then dropping rows with null entries (hint: df.dropna()).

The resulting DataFrame is returned with the column names taken from names.

2. split_data(df, xes_col_names, y_col_name, test_size = 0.33, random_state = 106): This function takes 5 input parameters:

• df: a DataFrame containing columns xes_col_names and y_col_name.

• xes_col_names: a list of column names of the independent variable.

• y_col_name: the name of the column of the dependent variable.

• test_size: accepts a float between 0 and 1 and represents the proportion of the data set to use for training. This parameter has a default value of 0.25.

• random_state: Used as a seed to the randomization. This parameter has a default value of 1870.

Returns the data split into 4 subsets, corresponding to those returned by train_test_split: x_train, x_test, y_train, and y_test. where xes_col_names is the “x” column and the input parameter, y_col_name is the “y” column.

Note: this is function is very similar to the splitting of data into training and testing sets from Program 2.

For example, let’s input the cookie dataset:

gives the output:

If we use the default for the last argument, the resulting DataFrame has the original column names:

gives the output:

We can then split the data into training and testing subsets:

gives the output:

Once you have written your function, test it locally on the small test files. When it works, upload to Gradescope. Given the size of the files that we evaluate your code, you will find it much faster to develop and test the code in your IDE than debugging and testing in Gradescope.

Now that we have the data, let’s do some quick plots to get some intuition about how the possible explanatory variables (e.g. the ingredients) explain the price of chocolate chip cookies:

which makes a scatter plot of each ingredient versus the chocolate cookie price, and includes the linear regression line with the 95% confidence interval for the regression highlighted:

The linear models, especially for chocolate and sugar, fits the data well, but the plots suggest a quadratic might fit better than a linear model with a single input. Let’s look at linear models that use multiple inputs, as well as polynomial models.

Multiple Linear Models¶

As we did with modeling miles-per-gallon (MPG) for cars, let’s build a multiple linear model using all inputs:

• fit_lin_reg(x_train, y_train) This function takes two inputs:

  • x_train: an array-like of numeric columns with no null values.

  • y_train: the target values in an array-like numeric column with no null values.

  Fits a (multiple) linear model to x_train and y_train, using sklearn.linear_model.LinearRegression (see previous lectures & textbook for details on setting up the model). The resulting model should be returned as bytestream, using pickle.

Continuing our example using all the training data sets that we partitioned above:

gives the output:

The pickled model is bytestream but is fairly short considering that it’s encoding the state of our trained model.

Polynomial Models¶

Next, let’s focus on a single independent variable and build models that use higher order (e.g. quadratic, cubic, etc.) terms to capture the relationship between the independent and dependent variables. A useful function underlying the three following functions is sklearn.preprocessing.PolynomialFeatures, which is available from scikit-learn.

• encode_poly(df, x_col, deg=2): This function takes three inputs:

  • df: a DataFrame that includes the column x_col.

  • x_col: a column name of the DataFrame df.

  • deg: an positive, integer value that is the degree of the polynomial feature. It has a default value of 2.

Using df[[x_col]] as an array (hint: pandas.DataFrame.to_numpy() converts a DataFrame to a Numpy array), returns the polynomial features of that column to degree deg. Returns the resulting array. Hint: see the Chapter 16 for examples of using PolynomialFeatures().

• fit_poly(xes, yes, epsilon=0.01, verbose=False): This function takes four inputs:

  • xes: a DataFrame that includes the column units.

  • yes: a series of the same length as xes.

  • epsilon: the size of the sample. It has a default value of 100.

  • verbose: when True, prints out the MSE cost for each degree tried (in format: f'MSE cost for deg {deg} poly model: {error:.3f}' for degrees 1, 2, ..., until the error is below epsilon, see example below). It has a default value of False.

It returns the smallest integer degree >= 1 for which the model yields a MSE of less than the specified epsilon and the coefficients as a vector for df["units"] and df[y_col]. If it does not find a model with an error less than epsilon by degree 5, returns None. When fitting the linear regression model, the fit_intercept=False. Hint: see the Chapter 16 for examples of using PolynomialFeatures().

• fit_with_regularization(xes, yes, poly_deg=2, reg="lasso"): This function takes four inputs:

  • xes: a series of numeric values.

  • yes: a series of numeric values.

  • poly_deg: the degree of the polynomial features to be created. It has a default value of 2.

  • reg: The type of regularization used: ridge or lasso. It has a default value of lasso.

This function fits a model with polynomial features using Lasso or Ridge regression with cross validation: 1. Apply PolynomialFeatures to the xes with degree equal to poly_deg. 2. If reg equals ridge, use RidgeCV to instantiate and fit a model to the polynomial features and yes. Otherwise, use LassoCV to to instantiate and fit the model. 3. Returns the model as serialized object (i.e. a pickled object).

Continuing our example with the chocolate column:

gives the polynomial features (printed prettily):

The first column is Chocolate**0 which is constantly 1. The next column is Chocolate**1 which is just the Chocolate column. The next columns are the square, Chocolate**2, and the cube, Chocolate**3, of the Chocolate column.

The next function tries different degree polynomials and stops when the MSE cost is less than epsilon or large (degree >=5). Trying first for eggs,

finds that no small degree yields an error less than epsilon:

Repeating with chocolate:

finds that degree = 3 yields an error less than epsilon:

The next function fits the model using regularization:

gives the output:

Evaluating Our Models¶

The next part of program evaluates how well our constant models do at prediction. We will use a loss function, mean squared error, introduced in Lecture 3 and Section 4.2.

- predict_using_trained_model(mod_pkl, xes, yes): This function takes three inputs:

• mod_pkl: a trained model for the data, stored in pickle format.

• xes: an array-like of numeric columns with no null values.

• yes: the target values as an array-like numeric column with no null values.

Computes and returns the mean squared error and r2 score between the values predicted by the model (mod_pkl on x) and the actual values (y). Note that sklearn.metrics contains two functions that may be of use: mean_squared_error and r2_score.

Continuing our example using models that we trained above:

gives the output:

As expected, the data on which the model was trained yields better mean squared error and r2 than the testing data.

We can use the function to predict with the polynomial features for chocolate:

gives the output:

The cubic model on just the chocolate column does similarly to the regression built on all the input indices.

Let’s visualize the model (red line) with the full data set:

which shows:

Testing Code¶

Each programming assignment includes functions that test that your code works (a “test suite”). In Programs 1 & 2, we wrote the test functions by hand. For this program, we will also use pytest, a standard Python testing framework. Before you start, make sure that your IDE has pytest installed:

Pytest is one of the most popular testing frameworks for Python. For this program, we will introduce the core testing features (and will introduce more features, such as parametrizing, in future programs). For more details, see Lecture 8, pytest docs and Think CS: Chapter 20.

• test_encode_poly(): This test function uses pytest to test the encode_poly() function. It assert True if encode_poly() is correct and False otherwise.

Trying first on the correct function, assuming that your program is called p3.py, we can invoke pytest from the command-line:

gives the output:

pytest looks for a function called: test_encode_poly() in the file p3.py. It then runs test_encode_poly(), which tests the correctness of the function encode_poly() and reports back the results.

Notes and Hints:

• You should submit a .py file with only the standard comments at the top, the specified functions, and any helper functions you have written. The grading scripts will then import the file for testing. If your file includes code outside of functions, either comment the code out before submitting or use a main function that is conditionally executed.

• Include only the libraries you need (such as pandas) for your functions and none of the ones for plotting (such as matplotlib.pyplot and seaborn) since the functions submitted are computing and not plotting. Only the libraries listed in Available Libraries are loaded by the autograder.