Patsy: Contrast Coding Systems for categorical variables

Note

This document is based on this excellent resource from UCLA.

A categorical variable of K categories, or levels, usually enters a regression as a sequence of K-1 dummy variables. This amounts to a linear hypothesis on the level means. That is, each test statistic for these variables amounts to testing whether the mean for that level is statistically significantly different from the mean of the base category. This dummy coding is called Treatment coding in R parlance, and we will follow this convention. There are, however, different coding methods that amount to different sets of linear hypotheses.

In fact, the dummy coding is not technically a contrast coding. This is because the dummy variables add to one and are not functionally independent of the model’s intercept. On the other hand, a set of contrasts for a categorical variable with k levels is a set of k-1 functionally independent linear combinations of the factor level means that are also independent of the sum of the dummy variables. The dummy coding is not wrong per se. It captures all of the coefficients, but it complicates matters when the model assumes independence of the coefficients such as in ANOVA. Linear regression models do not assume independence of the coefficients and thus dummy coding is often the only coding that is taught in this context.

To have a look at the contrast matrices in Patsy, we will use data from UCLA ATS. First let’s load the data.

Example Data

In [1]: import pandas

In [2]: url = 'https://stats.idre.ucla.edu/stat/data/hsb2.csv'

In [3]: hsb2 = pandas.read_csv(url)
---------------------------------------------------------------------------
ConnectionRefusedError                    Traceback (most recent call last)
/usr/lib/python3.10/urllib/request.py in do_open(self, http_class, req, **http_conn_args)
   1347             try:
-> 1348                 h.request(req.get_method(), req.selector, req.data, headers,
   1349                           encode_chunked=req.has_header('Transfer-encoding'))

/usr/lib/python3.10/http/client.py in request(self, method, url, body, headers, encode_chunked)
   1281         """Send a complete request to the server."""
-> 1282         self._send_request(method, url, body, headers, encode_chunked)
   1283 

/usr/lib/python3.10/http/client.py in _send_request(self, method, url, body, headers, encode_chunked)
   1327             body = _encode(body, 'body')
-> 1328         self.endheaders(body, encode_chunked=encode_chunked)
   1329 

/usr/lib/python3.10/http/client.py in endheaders(self, message_body, encode_chunked)
   1276             raise CannotSendHeader()
-> 1277         self._send_output(message_body, encode_chunked=encode_chunked)
   1278 

/usr/lib/python3.10/http/client.py in _send_output(self, message_body, encode_chunked)
   1036         del self._buffer[:]
-> 1037         self.send(msg)
   1038 

/usr/lib/python3.10/http/client.py in send(self, data)
    974             if self.auto_open:
--> 975                 self.connect()
    976             else:

/usr/lib/python3.10/http/client.py in connect(self)
   1446 
-> 1447             super().connect()
   1448 

/usr/lib/python3.10/http/client.py in connect(self)
    940         sys.audit("http.client.connect", self, self.host, self.port)
--> 941         self.sock = self._create_connection(
    942             (self.host,self.port), self.timeout, self.source_address)

/usr/lib/python3.10/socket.py in create_connection(address, timeout, source_address)
    844         try:
--> 845             raise err
    846         finally:

/usr/lib/python3.10/socket.py in create_connection(address, timeout, source_address)
    832                 sock.bind(source_address)
--> 833             sock.connect(sa)
    834             # Break explicitly a reference cycle

ConnectionRefusedError: [Errno 111] Connection refused

During handling of the above exception, another exception occurred:

URLError                                  Traceback (most recent call last)
<ipython-input-3-4735750ff492> in <module>
----> 1 hsb2 = pandas.read_csv(url)

/usr/lib/python3/dist-packages/pandas/util/_decorators.py in wrapper(*args, **kwargs)
    309                     stacklevel=stacklevel,
    310                 )
--> 311             return func(*args, **kwargs)
    312 
    313         return wrapper

/usr/lib/python3/dist-packages/pandas/io/parsers/readers.py in read_csv(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, error_bad_lines, warn_bad_lines, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options)
    584     kwds.update(kwds_defaults)
    585 
--> 586     return _read(filepath_or_buffer, kwds)
    587 
    588 

/usr/lib/python3/dist-packages/pandas/io/parsers/readers.py in _read(filepath_or_buffer, kwds)
    480 
    481     # Create the parser.
--> 482     parser = TextFileReader(filepath_or_buffer, **kwds)
    483 
    484     if chunksize or iterator:

/usr/lib/python3/dist-packages/pandas/io/parsers/readers.py in __init__(self, f, engine, **kwds)
    809             self.options["has_index_names"] = kwds["has_index_names"]
    810 
--> 811         self._engine = self._make_engine(self.engine)
    812 
    813     def close(self):

/usr/lib/python3/dist-packages/pandas/io/parsers/readers.py in _make_engine(self, engine)
   1038             )
   1039         # error: Too many arguments for "ParserBase"
-> 1040         return mapping[engine](self.f, **self.options)  # type: ignore[call-arg]
   1041 
   1042     def _failover_to_python(self):

/usr/lib/python3/dist-packages/pandas/io/parsers/c_parser_wrapper.py in __init__(self, src, **kwds)
     49 
     50         # open handles
---> 51         self._open_handles(src, kwds)
     52         assert self.handles is not None
     53 

/usr/lib/python3/dist-packages/pandas/io/parsers/base_parser.py in _open_handles(self, src, kwds)
    220         Let the readers open IOHandles after they are done with their potential raises.
    221         """
--> 222         self.handles = get_handle(
    223             src,
    224             "r",

/usr/lib/python3/dist-packages/pandas/io/common.py in get_handle(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)
    607 
    608     # open URLs
--> 609     ioargs = _get_filepath_or_buffer(
    610         path_or_buf,
    611         encoding=encoding,

/usr/lib/python3/dist-packages/pandas/io/common.py in _get_filepath_or_buffer(filepath_or_buffer, encoding, compression, mode, storage_options)
    310         # assuming storage_options is to be interpreted as headers
    311         req_info = urllib.request.Request(filepath_or_buffer, headers=storage_options)
--> 312         with urlopen(req_info) as req:
    313             content_encoding = req.headers.get("Content-Encoding", None)
    314             if content_encoding == "gzip":

/usr/lib/python3/dist-packages/pandas/io/common.py in urlopen(*args, **kwargs)
    210     import urllib.request
    211 
--> 212     return urllib.request.urlopen(*args, **kwargs)
    213 
    214 

/usr/lib/python3.10/urllib/request.py in urlopen(url, data, timeout, cafile, capath, cadefault, context)
    214     else:
    215         opener = _opener
--> 216     return opener.open(url, data, timeout)
    217 
    218 def install_opener(opener):

/usr/lib/python3.10/urllib/request.py in open(self, fullurl, data, timeout)
    517 
    518         sys.audit('urllib.Request', req.full_url, req.data, req.headers, req.get_method())
--> 519         response = self._open(req, data)
    520 
    521         # post-process response

/usr/lib/python3.10/urllib/request.py in _open(self, req, data)
    534 
    535         protocol = req.type
--> 536         result = self._call_chain(self.handle_open, protocol, protocol +
    537                                   '_open', req)
    538         if result:

/usr/lib/python3.10/urllib/request.py in _call_chain(self, chain, kind, meth_name, *args)
    494         for handler in handlers:
    495             func = getattr(handler, meth_name)
--> 496             result = func(*args)
    497             if result is not None:
    498                 return result

/usr/lib/python3.10/urllib/request.py in https_open(self, req)
   1389 
   1390         def https_open(self, req):
-> 1391             return self.do_open(http.client.HTTPSConnection, req,
   1392                 context=self._context, check_hostname=self._check_hostname)
   1393 

/usr/lib/python3.10/urllib/request.py in do_open(self, http_class, req, **http_conn_args)
   1349                           encode_chunked=req.has_header('Transfer-encoding'))
   1350             except OSError as err: # timeout error
-> 1351                 raise URLError(err)
   1352             r = h.getresponse()
   1353         except:

URLError: <urlopen error [Errno 111] Connection refused>

It will be instructive to look at the mean of the dependent variable, write, for each level of race ((1 = Hispanic, 2 = Asian, 3 = African American and 4 = Caucasian)).

In [4]: hsb2.groupby('race')['write'].mean()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-4-a0004b337d47> in <module>
----> 1 hsb2.groupby('race')['write'].mean()

NameError: name 'hsb2' is not defined

Treatment (Dummy) Coding

Dummy coding is likely the most well known coding scheme. It compares each level of the categorical variable to a base reference level. The base reference level is the value of the intercept. It is the default contrast in Patsy for unordered categorical factors. The Treatment contrast matrix for race would be

In [5]: from patsy.contrasts import Treatment

In [6]: levels = [1,2,3,4]

In [7]: contrast = Treatment(reference=0).code_without_intercept(levels)

In [8]: print(contrast.matrix)
[[0. 0. 0.]
 [1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

Here we used reference=0, which implies that the first level, Hispanic, is the reference category against which the other level effects are measured. As mentioned above, the columns do not sum to zero and are thus not independent of the intercept. To be explicit, let’s look at how this would encode the race variable.

In [9]: contrast.matrix[hsb2.race-1, :][:20]
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-9-eae0b0d66a00> in <module>
----> 1 contrast.matrix[hsb2.race-1, :][:20]

NameError: name 'hsb2' is not defined

This is a bit of a trick, as the race category conveniently maps to zero-based indices. If it does not, this conversion happens under the hood, so this will not work in general but nonetheless is a useful exercise to fix ideas. The below illustrates the output using the three contrasts above

In [10]: from statsmodels.formula.api import ols

In [11]: mod = ols("write ~ C(race, Treatment)", data=hsb2)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-11-3bdf176f3042> in <module>
----> 1 mod = ols("write ~ C(race, Treatment)", data=hsb2)

NameError: name 'hsb2' is not defined

In [12]: res = mod.fit()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-12-fa3ccf53f431> in <module>
----> 1 res = mod.fit()

NameError: name 'mod' is not defined

In [13]: print(res.summary())
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-13-ba064a039ab1> in <module>
----> 1 print(res.summary())

NameError: name 'res' is not defined

We explicitly gave the contrast for race; however, since Treatment is the default, we could have omitted this.

Simple Coding

Like Treatment Coding, Simple Coding compares each level to a fixed reference level. However, with simple coding, the intercept is the grand mean of all the levels of the factors. See User-Defined Coding for how to implement the Simple contrast.

In [14]: contrast = Simple().code_without_intercept(levels)

In [15]: print(contrast.matrix)
[[-0.25 -0.25 -0.25]
 [ 0.75 -0.25 -0.25]
 [-0.25  0.75 -0.25]
 [-0.25 -0.25  0.75]]

In [16]: mod = ols("write ~ C(race, Simple)", data=hsb2)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-16-6ce0487a5b61> in <module>
----> 1 mod = ols("write ~ C(race, Simple)", data=hsb2)

NameError: name 'hsb2' is not defined

In [17]: res = mod.fit()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-17-fa3ccf53f431> in <module>
----> 1 res = mod.fit()

NameError: name 'mod' is not defined

In [18]: print(res.summary())
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-18-ba064a039ab1> in <module>
----> 1 print(res.summary())

NameError: name 'res' is not defined

Sum (Deviation) Coding

Sum coding compares the mean of the dependent variable for a given level to the overall mean of the dependent variable over all the levels. That is, it uses contrasts between each of the first k-1 levels and level k In this example, level 1 is compared to all the others, level 2 to all the others, and level 3 to all the others.

In [19]: from patsy.contrasts import Sum

In [20]: contrast = Sum().code_without_intercept(levels)

In [21]: print(contrast.matrix)
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]
 [-1. -1. -1.]]

In [22]: mod = ols("write ~ C(race, Sum)", data=hsb2)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-22-fcaa6b96ccfd> in <module>
----> 1 mod = ols("write ~ C(race, Sum)", data=hsb2)

NameError: name 'hsb2' is not defined

In [23]: res = mod.fit()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-23-fa3ccf53f431> in <module>
----> 1 res = mod.fit()

NameError: name 'mod' is not defined

In [24]: print(res.summary())
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-24-ba064a039ab1> in <module>
----> 1 print(res.summary())

NameError: name 'res' is not defined

This corresponds to a parameterization that forces all the coefficients to sum to zero. Notice that the intercept here is the grand mean where the grand mean is the mean of means of the dependent variable by each level.

In [25]: hsb2.groupby('race')['write'].mean().mean()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-25-b21947de62cb> in <module>
----> 1 hsb2.groupby('race')['write'].mean().mean()

NameError: name 'hsb2' is not defined

Backward Difference Coding

In backward difference coding, the mean of the dependent variable for a level is compared with the mean of the dependent variable for the prior level. This type of coding may be useful for a nominal or an ordinal variable.

In [26]: from patsy.contrasts import Diff

In [27]: contrast = Diff().code_without_intercept(levels)

In [28]: print(contrast.matrix)
[[-0.75 -0.5  -0.25]
 [ 0.25 -0.5  -0.25]
 [ 0.25  0.5  -0.25]
 [ 0.25  0.5   0.75]]

In [29]: mod = ols("write ~ C(race, Diff)", data=hsb2)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-29-e28888f23177> in <module>
----> 1 mod = ols("write ~ C(race, Diff)", data=hsb2)

NameError: name 'hsb2' is not defined

In [30]: res = mod.fit()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-30-fa3ccf53f431> in <module>
----> 1 res = mod.fit()

NameError: name 'mod' is not defined

In [31]: print(res.summary())
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-31-ba064a039ab1> in <module>
----> 1 print(res.summary())

NameError: name 'res' is not defined

For example, here the coefficient on level 1 is the mean of write at level 2 compared with the mean at level 1. Ie.,

In [32]: res.params["C(race, Diff)[D.1]"]
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-32-f27d60ed9ed4> in <module>
----> 1 res.params["C(race, Diff)[D.1]"]

NameError: name 'res' is not defined

In [33]: hsb2.groupby('race').mean()["write"][2] - \
   ....:     hsb2.groupby('race').mean()["write"][1]
   ....: 
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-33-c6e56faf0508> in <module>
----> 1 hsb2.groupby('race').mean()["write"][2] - \
      2     hsb2.groupby('race').mean()["write"][1]

NameError: name 'hsb2' is not defined

Helmert Coding

Our version of Helmert coding is sometimes referred to as Reverse Helmert Coding. The mean of the dependent variable for a level is compared to the mean of the dependent variable over all previous levels. Hence, the name ‘reverse’ being sometimes applied to differentiate from forward Helmert coding. This comparison does not make much sense for a nominal variable such as race, but we would use the Helmert contrast like so:

In [34]: from patsy.contrasts import Helmert

In [35]: contrast = Helmert().code_without_intercept(levels)

In [36]: print(contrast.matrix)
[[-1. -1. -1.]
 [ 1. -1. -1.]
 [ 0.  2. -1.]
 [ 0.  0.  3.]]

In [37]: mod = ols("write ~ C(race, Helmert)", data=hsb2)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-37-c991b20b1c77> in <module>
----> 1 mod = ols("write ~ C(race, Helmert)", data=hsb2)

NameError: name 'hsb2' is not defined

In [38]: res = mod.fit()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-38-fa3ccf53f431> in <module>
----> 1 res = mod.fit()

NameError: name 'mod' is not defined

In [39]: print(res.summary())
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-39-ba064a039ab1> in <module>
----> 1 print(res.summary())

NameError: name 'res' is not defined

To illustrate, the comparison on level 4 is the mean of the dependent variable at the previous three levels taken from the mean at level 4

In [40]: grouped = hsb2.groupby('race')
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-40-717e908ca802> in <module>
----> 1 grouped = hsb2.groupby('race')

NameError: name 'hsb2' is not defined

In [41]: grouped.mean()["write"][4] - grouped.mean()["write"][:3].mean()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-41-a29d75116d4c> in <module>
----> 1 grouped.mean()["write"][4] - grouped.mean()["write"][:3].mean()

NameError: name 'grouped' is not defined

As you can see, these are only equal up to a constant. Other versions of the Helmert contrast give the actual difference in means. Regardless, the hypothesis tests are the same.

In [42]: k = 4

In [43]: 1./k * (grouped.mean()["write"][k] - grouped.mean()["write"][:k-1].mean())
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-43-8956699e0a60> in <module>
----> 1 1./k * (grouped.mean()["write"][k] - grouped.mean()["write"][:k-1].mean())

NameError: name 'grouped' is not defined

In [44]: k = 3

In [45]: 1./k * (grouped.mean()["write"][k] - grouped.mean()["write"][:k-1].mean())
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-45-8956699e0a60> in <module>
----> 1 1./k * (grouped.mean()["write"][k] - grouped.mean()["write"][:k-1].mean())

NameError: name 'grouped' is not defined

Orthogonal Polynomial Coding

The coefficients taken on by polynomial coding for k=4 levels are the linear, quadratic, and cubic trends in the categorical variable. The categorical variable here is assumed to be represented by an underlying, equally spaced numeric variable. Therefore, this type of encoding is used only for ordered categorical variables with equal spacing. In general, the polynomial contrast produces polynomials of order k-1. Since race is not an ordered factor variable let’s use read as an example. First we need to create an ordered categorical from read.

In [46]: _, bins = np.histogram(hsb2.read, 3)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-46-55fa0c232e59> in <module>
----> 1 _, bins = np.histogram(hsb2.read, 3)

NameError: name 'hsb2' is not defined

In [47]: try: # requires numpy main
   ....:     readcat = np.digitize(hsb2.read, bins, True)
   ....: except:
   ....:     readcat = np.digitize(hsb2.read, bins)
   ....: 
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-47-0c74b2d4fa61> in <module>
      1 try: # requires numpy main
----> 2     readcat = np.digitize(hsb2.read, bins, True)
      3 except:

NameError: name 'hsb2' is not defined

During handling of the above exception, another exception occurred:

NameError                                 Traceback (most recent call last)
<ipython-input-47-0c74b2d4fa61> in <module>
      2     readcat = np.digitize(hsb2.read, bins, True)
      3 except:
----> 4     readcat = np.digitize(hsb2.read, bins)

NameError: name 'hsb2' is not defined

In [48]: hsb2['readcat'] = readcat
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-48-e199b94a103d> in <module>
----> 1 hsb2['readcat'] = readcat

NameError: name 'readcat' is not defined

In [49]: hsb2.groupby('readcat').mean()['write']
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-49-97d196c364b0> in <module>
----> 1 hsb2.groupby('readcat').mean()['write']

NameError: name 'hsb2' is not defined
In [50]: from patsy.contrasts import Poly

In [51]: levels = hsb2.readcat.unique().tolist()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-51-4d972b7909b9> in <module>
----> 1 levels = hsb2.readcat.unique().tolist()

NameError: name 'hsb2' is not defined

In [52]: contrast = Poly().code_without_intercept(levels)

In [53]: print(contrast.matrix)
[[-0.6708  0.5    -0.2236]
 [-0.2236 -0.5     0.6708]
 [ 0.2236 -0.5    -0.6708]
 [ 0.6708  0.5     0.2236]]

In [54]: mod = ols("write ~ C(readcat, Poly)", data=hsb2)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-54-e9324312786f> in <module>
----> 1 mod = ols("write ~ C(readcat, Poly)", data=hsb2)

NameError: name 'hsb2' is not defined

In [55]: res = mod.fit()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-55-fa3ccf53f431> in <module>
----> 1 res = mod.fit()

NameError: name 'mod' is not defined

In [56]: print(res.summary())
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-56-ba064a039ab1> in <module>
----> 1 print(res.summary())

NameError: name 'res' is not defined

As you can see, readcat has a significant linear effect on the dependent variable write but not a significant quadratic or cubic effect.

User-Defined Coding

If you want to use your own coding, you must do so by writing a coding class that contains a code_with_intercept and a code_without_intercept method that return a patsy.contrast.ContrastMatrix instance.

In [57]: from patsy.contrasts import ContrastMatrix
   ....: 
   ....: def _name_levels(prefix, levels):
   ....:     return ["[%s%s]" % (prefix, level) for level in levels]
   ....: 

In [58]: class Simple(object):
   ....:     def _simple_contrast(self, levels):
   ....:         nlevels = len(levels)
   ....:         contr = -1./nlevels * np.ones((nlevels, nlevels-1))
   ....:         contr[1:][np.diag_indices(nlevels-1)] = (nlevels-1.)/nlevels
   ....:         return contr
   ....: 
   ....:     def code_with_intercept(self, levels):
   ....:         contrast = np.column_stack((np.ones(len(levels)),
   ....:                                    self._simple_contrast(levels)))
   ....:         return ContrastMatrix(contrast, _name_levels("Simp.", levels))
   ....: 
   ....:    def code_without_intercept(self, levels):
   ....:        contrast = self._simple_contrast(levels)
   ....:        return ContrastMatrix(contrast, _name_levels("Simp.", levels[:-1]))
   ....: 
  File "<tokenize>", line 13
    def code_without_intercept(self, levels):
    ^
IndentationError: unindent does not match any outer indentation level


In [60]: mod = ols("write ~ C(race, Simple)", data=hsb2)
   ....: res = mod.fit()
   ....: print(res.summary())
   ....: 
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-60-b06f36e8be6e> in <module>
----> 1 mod = ols("write ~ C(race, Simple)", data=hsb2)
      2 res = mod.fit()
      3 print(res.summary())

NameError: name 'hsb2' is not defined