Computational Analyses Connect Small-Molecule Sensitivity to Cellular Features Using Large Panels of Cancer Cell Lines

Abstract

We recently pioneered several analyses of small-molecule sensitivity data collected from large-scale perturbation of hundreds of cancer cell lines with hundreds of small molecules, with cell viability measured as a readout of compound sensitivity. We performed these studies using cancer cell lines previously annotated with cellular, genomic, and basal gene-expression features. By combining small-molecule sensitivity data with these other datasets, we identified new candidate biomarkers of sensitivity, gained insights into small-molecule mechanisms of action, and proposed candidate hypotheses for cancer dependencies (including candidate combination therapies). Nevertheless, given the size of these datasets, we expect that many connections between cellular features and small-molecule sensitivity remain under-explored. In this chapter, we provide a step-by-step account of foundational data-analysis methods underlying our published studies, including working MATLAB code applied to our own public datasets. These procedures will allow others to repeat analyses of our data with new parameters, in additional contexts, and to adapt our procedures to their own datasets.

1. Introduction

In this chapter, we provide a hands-on MATLAB walk-through of foundational data-analysis procedures underlying the results in the Cancer Therapeutics Response Portal (CTRP; https://portals.broadinstitute.org/ctrp/), which provides access to data and visualizations stemming from small-molecule sensitivity profiling of cancer cell lines [1–3]. When combined with large-scale genomic and transcriptomic characterization of cancer cell lines, such as those from the Cancer Cell Line Encyclopedia (CCLE) [4] and the Genomics of Drug Sensitivity in Cancer (GDSC) [5–7], small-molecule sensitivity data have been used to identify new candidate cancer dependencies [1–3,8–14]. Their availability has also stimulated development of foundational analysis methods to find novel cancer dependencies in these or similar data, such as those emerging from genetic perturbation experiments in cancer cell lines [15–18].

Foundational analysis methods for CTRP include creating cell-line sensitivity profiles [1–3] based on area-under-curve (AUC) values computed from concentration-response curves; enrichment analysis for cellular (lineage or mutational) features among cell lines sensitive to small molecules [1,2]; and cross-correlation analysis of small-molecule sensitivity with basal gene-expression patterns [3]. The data underlying CTRP have also been used in the development of several additional methods that integrate prior knowledge, harness new datasets, or result in more complex models. For example, we developed annotated cluster multidimensional enrichment (ACME) analysis [2], a novel method to combine clustering of small-molecule sensitivity data with prior knowledge (e.g., about compound targets or cellular pathways) to formulate new cancer-dependency hypotheses.

The emergence of these datasets has excited the computational biology community, as there is a need for novel method development to mine these data and uncover novel connections. Other recent methods that include a component of small-molecule sensitivity analysis include DAISY [19], DiSCoVER [20], EDDY [21], OncoGPS [22], and RWEN [23]; extensions to The Cancer Proteome Atlas (TCPA) [24,25] and GDSC itself [26]; and a number of other related studies [27–32]. This rapid proliferation of tools, methods, and comparative analyses has also sparked an important line of critical reflection about the reproducibility of findings and their concordance across different data sources with different experimental designs [33–36]. These developments evince an appetite in the computational biology community to use small-molecule sensitivity profiling data in diverse and creative ways.

Accordingly, we present this chapter to carefully describe the foundational analyses of CTRP, showcase a MATLAB reference implementation of them, and share tips, caveats, and other considerations that we encountered during their development. We cover three procedures in detail:

• Procedure 1: preparation of concentration-response areas-under-curve (AUCs) as a measure of small-molecule sensitivity [1–3]

• Procedure 2: enrichment analysis of mutation features among cell lines of a particular lineage sensitive to individual compounds [1,2]

• Procedure 3: correlation analysis of basal gene-expression levels to compound sensitivity across panels of cell lines from a lineage [3]

In each case, the procedure selects at random an appropriate subset of available public data and is followed by a basic visualization, interpretable by users without a strong computational background, that illustrates the essential output, including statistical and quality-control measures we use to prioritize the most important connections. We focus on datasets that best illustrate the core steps in the analysis and that best highlight important tips and caveats. Our goal here is to present step-by-step instruction in the core methods, including working code, advice, and notes on the process, rather than highlight specific findings of potential biological interest. Indeed, our choice of including a random component into each analysis subset selection means not only that specific output figures will differ from run to run, but also that the code in principle could highlight a previously unappreciated biological connection. We strive to present the workflow in a manner that is logically modular, so that studies of reproducibility (by removing the random component), extensions to larger data subsets (at the cost of run-time), and the addition of other perturbations (e.g., new compounds, genetic perturbations) or alternative cellular features (e.g., proteomic, metabolomic, or epigenomic features), are straightforward for a user with baseline familiarity in MATLAB.

2. Materials

Conceptually, the analyses presented in the chapter are general enough to be carried out in any programming language. In our experience, scientific computing software, such as R (R Foundation for Statistical Computing; Vienna, Austria) or MATLAB (MathWorks, Inc.; Natick, MA), provides the appropriate balance of flexibility and the provision of built-in functions for common data manipulations. Therefore, to minimize environment configuration, and focus the discussion on the core principles of the analyses, we have based this narrative on a modular MATLAB reference implementation designed to operate on publicly available data and metadata files.

2.1. Supplementary ZIP file

The code to accompany this chapter is provided as a supplementary ZIP file (implement.zip) containing the main script (master.m) and 3 subservient procedural scripts (code\scr folder), plus all custom functions necessary to execute the procedures (code\fun folder and subfolders). The ZIP file also contains a pre-configured directory structure, with folders to house input data (data folder), input metadata (meta folder), and output tables (out folder). The supplementary ZIP file can be downloaded from GitHub (https://github.com/remontoire-pac/ctrp-reference; see Note 1). The ZIP file should be unpacked using a standard utility and placed in the local computing environment in a location that can be added to the MATLAB search path (see Note 2).

2.2. MATLAB Environment

The implementation described in this chapter was initially developed on a Dell OptiPlex 9020 (Intel i7–4790 CPU @ 2×3.60GHz, 32.0 GB RAM) running 64-bit Windows 7 Enterprise, Service Pack 1, and MATLAB 2014b. Development was completed, and main testing performed, on a virtual machine (Intel Xeon CPU E5–2695 v4 @ 2×2.10GHz, 32.0 GB RAM) running Windows Server 2016 Datacenter and MATLAB 2018a. Development was initiated in MATLAB 2014b, and this is the earliest version of MATLAB that can execute the complete set of procedures as written, due to the addition of fishertest.m in that release. The procedures require the MATLAB Statistics and Machine Learning Toolbox (called the Statistics Toolbox in MATLAB 2014b), along with the author-provided custom functions. A successful independent set of tests was completed on a Microsoft Surface Pro 4 (Intel i7–6650 CPU @ 2×2.20GHz, 16 GB RAM) running 64-bit Windows 10 Pro and MATLAB 2017b. In all 3 of these environments, the entire code package runs in 5—10 minutes and creates 3 figures, with some time variation per instantiation depending on the random component of data subset selection for analysis (see Note 3).

2.3. Downloading Public Datasets

All data and metadata required to run the analyses presented in this chapter are available for free public download from the National Cancer Institute (NCI) Office of Cancer Genomics (OCG) and were originally produced in our laboratories as part of work supported by the Cancer Target Discovery and Development (CTD²) Network of research centers (see Note 4). To complete the download and deployment of the necessary input files for analysis, the following steps are sufficient:

1. Navigate a web browser to the OCG FTP server link ftp://caftpd.nci.nih.gov/pub/OCG-DCC/CTD2/Broad/.

2. Navigate down to the directory CTRPv2.0_2015_ctd2_ExpandedDataset and download the ZIP file CTRPv2.0_2015_ctd2_ExpandedDataset.zip.

3. Extract the file v20.data.per_cpd_pre_qc.txt and place it in the local data folder (created by unpacking the Supplementary ZIP file implement.zip in the local environment; see Section 2.1).

4. Extract the files v20.meta.per_cell_line.txt, v20.meta.per_compound.txt, and v20.meta.per_experiment.txt, and place them in the local meta folder.

5. Return to the parent FTP directory, navigate down to the directory CTRPv2.2_2015_pub_CancerDisc_5_1210, and download the ZIP file CTRPv2.2_2015_pub_CancerDisc_5_1210.zip.

6. Extract the files v22.data.auc_sensitivities.txt, v22.anno.ccl_anno_features.txt, and v22.anno.ccl_mut_features.txt, and place them in the local data folder.

7. Extract the file v22.meta.per_compound.txt and place it in the local meta folder.

8. Return to the parent FTP directory, navigate down to the directory CTRPv2.1_2016_pub_NatChemBiol_12_109, and download the ZIP file CTRPv2.1_2016_pub_NatChemBiol_12_109.zip.

9. Extract the files v21.data.auc_sensitivities.txt and v21.data.gex_avg_log2.txt, and place them in the local data folder.

10. Extract the files v21.meta.gex_features.txt and v21.meta.per_compound.txt, and place them in the local meta folder.

3. Methods

Each of the following procedures features a specific analysis that assumes the user has downloaded and unpacked the author-provided files (see Section 2.1), configured an appropriate MATLAB environment (see Section 2.2), and downloaded the relevant public datasets (see Section 2.3).

3.1. Sensitivity Calculation from Small-Molecule Concentration-Response Data

1. Read input data and experiment metadata as DataFrames to prepare for curve-fitting analysis (master.m, lines 21–23; see Note 5).

2. Walk-through (Step 3) or run (skip to Step 21) the first subsidiary script (procedure1CurveFit.m) to perform curve-fit analysis (master.m, line 25; see Note 6).

3. Index input DataFrame with unique combinations of compound and experiment identifiers (procedure1CurveFit.m, lines 1—2; see Note 7).

4. Reconcile relationships between experiment identifiers and cell lines (procedure1CurveFit.m, lines 4—6; see Note 8).

5. Define a set of curves to be fit (procedure1CurveFit.m, lines 8–10; see Note 9).

6. Create an empty MATLAB structure to hold the curve-fitting results (procedure1CurveFit.m, lines 12—13).

7. Define concentration limits for area-under-curve (AUC) numeric integration (procedure1CurveFit.m, lines 15—17; see Note 10).

8. Initialize curve-fit parameters and options for non-linear fits (procedure1CurveFit.m, lines 19—22; see Note 11).

9. Get data points for an individual curve fit and AUC integration (procedure1CurveFit.m, lines 28—34; see Note 12).

10. Seed curve-fit parameters by guessing log₂(EC₅₀) from the data (procedure1CurveFit.m, lines 36—42; see Note 13).

11. Handle data censoring depending on the value of a pre-computed quality-control type (procedure1CurveFit.m, lines 44—72; see Note 14).

12. Decide whether enough data points remain to perform a curve fit (procedure1CurveFit.m, lines 75—97; see Note 15).

13. Provisionally fit a 3-parameter sigmoid curve to data points (procedure1CurveFit.m, lines 99—103).

14. Conditionally fit a 2-parameter sigmoid curve depending on apparent log₂(EC₅₀) of the provisional 3-parameter fit (procedure1CurveFit.m, lines 105–112; see Note 16).

15. Append the current curve-fit results to the growing MATLAB structure (procedure1CurveFit.m, lines 116–134; see Note 17).

16. Create output DataFrames for fitted-curve per-point and per-curve data for all fit curves (procedure1CurveFit.m, lines 138—141).

17. Iterate over curve-fit results structure to build DataFrames for quality control and output (procedure1CurveFit.m, lines 143—218; see Note 18).

18. Define post curve-fit quality-control filters and apply to DataFrames (procedure1CurveFit.m, lines 220—241; see Note 19).

19. Resolve experiment identifiers to cell-line identifiers (procedure1CurveFit.m, lines 243—245; see Note 20).

20. Write output files for downstream analysis and interpretation (procedure1CurveFit.m, lines 247—249).

21. Read additional metadata containing compound and cell-line information for interpretation and for figure labels (master.m, lines 27—29; see Note 21).

22. Select suitable curves to illustrate concentration-response curve fit and extract data (master.m, lines 31—43; see Note 22).

23. Plot both original data and predicted curves with error bars to produce a variant of Figure 1 (master.m, lines 45—62; see Note 23).

Figure 1:

Representative curve-fit visualization showing the differential sensitivity of two cell lines. Two plots are presented for each of two cell lines, one more sensitive (red) and one less sensitive (blue), to navitoclax, a compound annotated in the Cancer Therapeutics Response Portal (CTRP; http://portals.broadinstitute.org/ctrp) as an inhibitor of BCL2, BCL-xL, and BCL-W. Unconnected crosses represent the original data and are labeled in the MATLAB figure legend with the cell-line name. Line plots with error bars represent the corresponding fit curves and are labeled in the MATLAB figure legend with the computed area-under-curve (AUC).

3.2. Mutation Enrichment among Small-Molecule Sensitive Cell Lines

1. Read input data and metadata as DataFrames to prepare for enrichment analysis (master.m, lines 66—69; see Note 24).

2. Walk-through (Step 3) or run (skip to Step 16) the second subsidiary script (procedure2Enrichment.m) to perform enrichment analysis (master.m, line 71; see Note 25).

3. Index input DataFrame with unique combinations of compound and experiment identifiers (procedure2Enrichment.m, lines 1—2; see Note 26).

4. Verify that indices for rows and columns match compounds and cell lines, respectively (procedure2Enrichment.m, lines 4—6).

5. Create a matrix of sensitivity values for compounds by cell lines (procedure2Enrichment.m, lines 8—12; see Note 27).

6. Create an indicator (i.e., binary) matrix of cell lineage and histology features by cell lines (procedure2Enrichment.m, lines 15—18; see Note 28).

7. Define a subset of cell lines to be tested and restrict compound data to this subset (procedure2Enrichment.m, lines 20—25; see Note 29).

8. Create an indicator (i.e., binary) matrix of cellular mutation features by cell lines and restrict this matrix to the same cell-line subset (procedure2Enrichment.m, lines 27—34; see Note 30).

9. Restrict analysis to mutation features with an appropriate number of examples (procedure2Enrichment.m, lines 36—39; see Note 31).

10. Define a set of compounds to be tested (procedure2Enrichment.m, lines 41—43; see Note 32).

11. Create an empty DataFrame to hold enrichment results (procedure2Enrichment.m, lines 45—48; see Note 33).

12. For a given compound to be tested, verify that enough cell lines were examined, and compute raw enrichment output using Fisher’s exact tests (procedure2Enrichment.m, lines 52—58; see Note 34).

13. For the current compound, record cell lineage, compound, and mutation feature labels, and append labeled results to the growing result DataFrame (procedure2Enrichment.m, lines 60—66; see Note 35).

14. When all compounds are tested (by iterating over Steps 12—13), define statistical and quality-control filters for all enrichment results (procedure2Enrichment.m, lines 70—77; see Note 36).

15. Apply filters to raw enrichment results and write output files for downstream analysis and interpretation (procedure2Enrichment.m, lines 79—83; see Note 37).

16. Read additional metadata containing compound information for interpretation and for figure labels (master.m, lines 73—74; see Note 38).

17. Select suitable results to illustrate enrichment analysis and extract data (master.m, lines 76—90; see Note 39).

18. Perform one-sided T-test as an additional statistical annotation for boxplots (master.m, lines 92—93).

19. Create labels for visualizations using appropriate metadata (master.m, lines 95—98; see Note 40).

20. Plot enrichment results as both heatmap and boxplot representations to produce a variant of Figure 2 (master.m, lines 100—122; see Note 41).

Figure 2:

Representative visualization of enrichment analysis for a single compound tested in multiple cell lines of the same type. In this case, 25 breast-derived cancer lines were tested with RAF265 (annotated in CTRP as an inhibitor of VEGFR2 and BRAF), and then sorted by area-under concentration-response curve (AUC) in the top left panel (increasing red color represents lower AUCs below the mean and therefore more sensitivity). Enrichment analysis resulted in an optimal cutoff of AUC < 12.2 which corresponds to 8 total cell lines in the bottom left panel, of which 6 carry a coding mutation in TNRC6B (red = has mutation; pink = lacks mutation). These were the only 6 TNRC6B mutants in this subset of 25 breast cancer-derived cell lines. The right panel depicts an alternative representation (box-whisker plot) and statistical analysis (t-test) of the same information, showing the relative distribution of AUC values for cell lines with or without coding mutations in TNRC6B.

3.3. Correlation of Small-Molecule Sensitivity with Basal Gene-Expression

1. Read input data as DataFrames to prepare for correlation analysis (master.m, lines 126—128; see Note 42).

2. Walk-through (Step 3) or run (skip to Step 17) the third subsidiary script (procedure3Correlation.m) to perform correlation analysis (master.m, line 130; see Note 43).

3. Index input DataFrame with unique combinations of compound and cell-line identifiers (procedure3Correlation.m, lines 1—2; see Note 44).

4. Create a matrix of sensitivity values for compounds by cell lines (procedure3Correlation.m, lines 4—8; see Note 45).

5. Index gene-expression DataFrame with unique combinations of gene and cell-line identifiers (procedure3Correlation.m, lines 10—11; see Note 46).

6. Create a matrix of gene-expression features by cell lines (procedure3Correlation.m, lines 13—17; see Note 47).

7. Define a subset of cell lines to be tested (procedure3Correlation.m, lines 19—22; see Note 48).

8. Restrict cell lines considered to those with both sensitivity and expression data (procedure3Correlation.m, lines 24—27; see Note 49).

9. Restrict genes considered to those with adequate dynamic range (procedure3Correlation.m, lines 29—33; see Note 50).

10. Restrict compounds considered to those with differentially sensitive cell lines (procedure3Correlation.m, lines 35—37; see Note 51).

11. Define a set of compounds to be tested (procedure3Correlation.m, lines 39—40; see Note 52).

12. Compute raw correlation output using normalized Pearson correlation coefficients (procedure3Correlation.m, lines 42—43; see Note 53).

13. Compute p-values and index to statistically filter the output correlations (procedure3Correlation.m, lines 45—48; see Note 54).

14. Create a results DataFrame and append cell lineage labels, plus compound and gene identifiers (procedure3Correlation.m, lines 50—57; see Note 55).

15. Append p-values, correlation z-scores, correlation coefficients, and the numbers of participating cell lines to results DataFrame (procedure3Correlation.m, lines 59—63; see Note 56).

16. Define and apply correlation quality-control filters, then write output DataFrame (procedure3Correlation.m, lines 65—86; see Note 57).

17. Read additional metadata containing gene information for interpretation and for figure labels (master.m, lines 132–133).

18. Select suitable correlation results to illustrate correlation analysis and extract data (master.m, lines 135—142; see Note 58).

19. Create labels for visualizations using appropriate metadata (master.m, lines 144—147; see Note 59).

20. Plot correlation results as a scatterplot to produce a variant of Figure 3 (master.m, lines 149—161; see Note 60).

Figure 3:

Representative visualization of correlation analysis for a single compound tested in multiple cell lines of the same type. In this case, 15 bone-derived cancer lines were tested with gemcitabine (annotated in CTRP as an inhibitor of CMPK1, RRM1, TYMS). Sensitivity to gemcitabine (low AUC) is correlated with low expression of SERPINE1 in these cell lines, and each of the AUC and gene-expression distributions exhibit good dynamic ranges as described in the text (see also Note 57).

4. Notes

1. We anticipate that the GitHub repository may grow over time, possibly including code updates, additional procedures, and other information. However, we will keep the original version corresponding exactly to this chapter available indefinitely.

2. To keep the distribution file size small, we include the complete directory structure, but do not redistribute the source data and metadata. Rather, we include instructions for downloading the data and metadata from the National Cancer Institute (see also Section 2.3).

3. The demonstration code uses judiciously-sized subsets of compounds for each procedure to keep total run-time down while still providing a complete analysis. Our recent production dataset [2,3] includes 481 small molecules, and we imagine the provided code could be easily modified to perform a global analysis of the complete dataset.

4. The National Cancer Institute (NCI) has supported multiple Cancer Target Discovery and Development (CTD²) Centers nationwide in the United States through several rounds of funding with an evolving mission directed at improving cancer patient outcomes with basic research activities. The Cancer Therapeutics Response Portal (CTRP) is one flagship project resulting from the Broad Institute’s Chemical Biology and Therapeutics Science program participating in the NCI-funded CTD² effort.

5. Throughout these procedures, we use a special type of MATLAB structure called a DataFrame, which was developed by Hyman Carrel in one of our laboratories (PAC) over a decade ago, inspired by data frames in R. DataFrames are MATLAB structures with one or more fields, constrained to each contain column vectors of equal length, but which collectively may mix numeric and text data types. In more modern releases of MATLAB, the utility of DataFrames has been essentially supplanted by the new MATLAB table variable type.

6. On first use, we recommend simply running the subsidiary script from within master.m, and skipping to Step 21. Doing so will ensure the user can get to Figure 1 more quickly and validate that procedure1CurveFit.m runs to completion in their environment. Detailed exploration of the inner workings of procedure1CurveFit.m (Steps 3—20) can be saved for later exploration.

7. In several steps, we make use of a special indexing function for DataFrames (DFindex.m) that allows for rapid conversion of tabular data to matrices and without requiring complete data or that tabular data be pre-sorted. We recommend studying the documentation within DFindex.m (and other DataFrame functions) to learn how it operates in detail.

8. During our cell-sensitivity profiling studies, we envisioned profiling data acquisition as a matrix of tests representing compounds by cell lines. As described in the relevant publications [2,3], however, the reality was less tidy. Checking the identity of cell lines by single-nucleotide-polymorphism (SNP) fingerprinting [16] revealed that sample-handling issues had resulted in a small fraction of intended cell lines being omitted, while others were inadvertently tested twice (or three times in one case). An important consequence of these practical considerations for data analysis is that the relationship of an experiment (a specific cell-line sample exposed to a compound collection) to a cell line (an abstract entity annotated with prior information about lineage, mutation, or basal gene expression) is not one-to-one. The public metadata reflects these details, and the exhibition code accounts for them.

9. In the demonstration, we select a single compound at random and fit all curves available for that compound. The code could easily be modified to select a specific compound of the user’s choice, and we recommend such a modification as a first step in customizing the analysis. More aggressive modifications might include studying multiple compounds, a single cell line across all compounds, or all possible curves in the dataset. However, such modifications will also require modification of the visualization code for Figure 1, since the current visualization code for curve-fitting expects a single compound.

10. In our earlier studies [1–3], we set limits of integration for area-under-curve (AUC) that were based on the concentrations tested for each compound individually, making the comparison of AUC values across compounds potentially problematic. In this chapter, consistent with our current best practices, we define a single set of integration limits across all compounds in the dataset, normalized from 0 (complete killing) to 1 (equivalent to untreated controls).

11. We seed 3 of the 4 possible sigmoid curve parameters here; the concentration parameter, log₂(EC₅₀), is seeded later, using the response data to improve the initial guess.

12. Within the for loop, data for each curve are collected and processed in a set of temporary variables that are reset with each loop iteration. Data kept for output are stored in a growing MATLAB structure before the loop ends.

13. We seed the concentration parameter, log₂(EC₅₀), at this stage, using the response data to improve the initial guess by choosing either the lowest concentration at which 50% cell killing is achieved, or the median percent killing if 50% cell killing is not achieved at any concentration.

14. In practice, we observed a number of different issues with data quality in our experiments, and therefore defined in data pre-processing [2] some quality-control measures (“QC-types”). Most curves either stayed flat (no compound effect) or relatively smoothly descended from no cell killing at low concentration to maximal cell killing at high concentration (QC-type 0). We observed cases where the top one (QC-type 1) or top two (QC-type 2) concentrations returned to the “no effect” baseline after observing concentration-dependent cell killing at lower concentrations. These aberrant data points are likely due to compound precipitation in the assay plate and were therefore omitted. We also observed cases where fluctuations in the data were more complex, presumably due to liquid-handling and other plate-reader artifacts (QC-type 3). In these cases, we used standard methods to censor individual data points (see the author-included function cooksdist.m for details).

15. In practice, we only fit curves with at least five data points passing pre-fit quality control. We regard this as a permissive choice, particularly for 16-point concentration-response experiments.

16. While curve-fits whose right asymptote is between 1 (no killing) and 0 (complete killing) are relatively common and may reflect a biological distinction between cytostatic effects of a compound and true cell killing, we noted a curve-fit failure mode where the predicted lower asymptote was strongly negative, which is not meaningful. This situation occurs when the predicted log₂(EC₅₀) is higher than the highest concentration tested. In such cases, we re-fit the curve with the lower asymptote constrained to zero.

17. To accommodate the fact that we eventually want two outputs, one with per-curve information and one with per-point information, we use an intermediate MATLAB structure to accumulate curve-fitting results and prepare the two desired outputs in a separate step.

18. We create two output DataFrames simultaneously. The first is for per-curve data, which is created directly by looping over the intermediate MATLAB structure, and accounts both for missing curves and whether a 3-parameter or 2-parameter curve is reported. The second is for per-point data and is created by appending to a growing DataFrame with each turn of the loop since the number of points to be included at each turn is not known in advance.

19. During our studies [2,3], we scanned thousands of concentration-response curves and identified multiple modes of failure. While these problematic curves represented a relatively small fraction, they fell into categories that we were able to trap computationally and exclude. Both the in-code documentation and our prior reports [2] detail the specific failure modes. These steps also illustrate the use of DFkeeprow.m, which applies the typical MATLAB logical or linear indexing to DataFrames.

20. To allow connection to cell-line metadata (e.g., the cell-line name), we reconcile the experiment number with the cell-line identifier at this stage (see also Note 8).

21. Each of our prior studies [1–3] uses a different subset of cell lines from the Cancer Cell Line Encyclopedia [4], and they also consider overlapping but not identical sets of compounds. To aid in reconciliation between datasets, we use global identifiers master_cpd_id (for compounds) and master_ccl_id (for cell lines) that have a shared meaning across all CTRP datasets.

22. To illustrate differential sensitivity, we choose a cell line among the top 5% of responders (sensitive) and a cell line near the median responder. These choices could easily be modified to display, for example, the most and least responsive cell lines.

23. The figure code is deliberately included in the calling script master.m for transparency and to allow facile modification by users without disrupting the scripts that do the calculations. Users are encouraged to further customize the appearance of figures according to their preferences.

24. In this procedure, two types of categorical variable are introduced, one describing the provenance of cancer cell lines as context to understand their sensitivity (primary site or lineage, histology terms, and other demographic information), and the other describing their mutational status.

25. On first use, we recommend simply running the subsidiary script from within master.m, and skipping to Step 16. Doing so will ensure the user can get to Figure 2 more quickly and validate that procedure2Enrichment.m runs to completion in their environment. Detailed exploration of the inner workings of procedure2Enrichment.m (Steps 3—15) can be saved for later exploration.

26. The original study [2] uses consecutive internal indices for compounds and cell lines in addition to the master identifiers (see also Note 21).

27. We anticipate missing data in the matrix of sensitivity scores by first seeding an appropriately-sized matrix with NaN (not a number) values, then filling in known values in a for loop over the indexed DataFrame.

28. In the present procedure, we use lineage and histology information about cell lines as a context feature to pick a subset of cell lines to study. We note that one could as easily check for enrichment of a single cell lineage versus all other lineages by treating lineage as a feature analogous to the way mutations are treated in the reference code.

29. We select a lineage, histology, or demographic term with at least 16 representative cell lines, but fewer than 25% of all cell lines, for illustration purposes. The user can modify these choices to expand the set of terms available or modify the code to specify a lineage of interest.

30. In the present procedure, we use mutation feature information as the primary type of feature for enrichment analysis, but we note that one could as easily use mutations for context (as we do here with lineage and histology information) to derive new and potentially interesting groups of cell lines, e.g., for enrichment or correlation analyses.

31. We choose among mutation features with at least 3 representative cell lines, but fewer than 50% of all cell lines, for illustration purposes. The user can modify these choices to expand the set of features available or modify the code to specify a mutation of interest.

32. We choose 12 random compounds, strictly to keep demonstration run-times low. Increasing the number of compounds, including choosing specific subsets of a user’s interest, is an obvious and recommended starting point for user customization.

33. The DataFrame to hold enrichment results will be grown by appending new rows because the number of rows to be appended will not, in general, be known in advance. Therefore, each field in the DataFrame is defined in advance and populated with an empty array.

34. The primary enrichment analysis at this stage is to perform many Fisher’s exact tests both to detect the optimal AUC cutoff for each compound and to iterate over candidate mutation features. We implement this feature using the custom function sensenfex.m. Importantly, this function avoids redundant calculations by first building an array of unique 2×2 contingency tables and tracking their relationship to metadata indices. We recommend studying the documentation within sensenfex.m to learn how it operates in detail.

35. The first output variable from sensenfex.m allows direct appending of mutational feature labels to the growing DataFrame along with the compound and lineage under consideration.

36. Experience has shown that statistical significance of an enrichment result is necessary but not sufficient to warrant continued biological interest. Accordingly, we filter on several other parameters, such as the minimum AUC (the compound must reliably kill at least one cell line), the enrichment confidence (fraction of mutant cell lines killed by the compound), the enrichment purity (fraction of sensitive cell lines harboring the mutation), and the enrichment overlap (at least two mutant cell lines must be sensitive). To ensure that the code produces at least one output for visualization, the enrichment with the best p-value is retained, even if it fails all the other criteria.

37. This step illustrates a relatively simple use of DFkeeprow.m to apply an accumulated set of filters (see also Note 19). To see output corresponding to those results passing each filter, a user could call DFkeeprow.m using each of the separate components (procedure2Enrichment.m, lines 71—76) in turn.

38. To use the consecutive compound index applied to the data from the original study [2], this procedure leverages the metadata file specific to that study (see also Note 26).

39. With the extensive pre-filtering of enrichment results based on confidence, purity, and overlap, the selection of data for visualization simply takes the most statistically significant result remaining after applying the filters. However, multiple parameters besides the p-value are retrieved from the results record for use in the visualization.

40. We note that human-readable context names and cell-line features are procured for use in the visualization directly from the result table, while compound names are procured from the master metadata. In general, we prefer a discipline where each human-readable string is stored exactly once, and database-like identifiers are used to represent data as far into a procedure as possible (e.g., until needed for visualization). We deliberately employed a mixed strategy here for illustration purposes.

41. The figure code is deliberately included in the calling script master.m (see also Note 23).

42. In this procedure, new numeric data are imported for AUCs, as well as for basal gene-expression values corresponding to our prior study of their cross-correlations [3]. However, we re-use the compound metadata from Procedure 1 and the cellular provenance information (lineage, histology, demographic) data from Procedure 2. Thus, if Procedure 3 is run in isolation, users should still load all data and metadata files specified in master.m.

43. On first use, we recommend simply running the subsidiary script from within master.m, and skipping to Step 17. Doing so will ensure the user can get to Figure 3 more quickly and validate that procedure3Correlation.m runs to completion in their environment. Detailed exploration of the inner workings of procedure3Correlation.m (Steps 3—16) can be saved for later exploration.

44. Unlike Procedure 2, here we use the master identifiers for compounds and cell lines (see also Note 21 and Note 26).

45. Again, we seed an appropriately-sized matrix with NaN (not a number) values to anticipate missing data (see also Note 27).

46. Indexing a DataFrame of gene-expression scores by cell lines works just as it does for AUCs by cell lines, but instead using a unique numeric identifier for gene names (see also Note 7).

47. As complete coverage of all cell lines with gene-expression data is not guaranteed, we start by seeding an appropriately-sized matrix with NaN (not a number) values (see also Note 27 and Note 45).

48. We select a lineage (primary site) with at least 16 representative cell lines for illustration purposes. The user can modify this choice to expand the set of terms available or modify the code to specify a lineage of interest.

49. Though our correlation procedure can handle missing values, we save some computation time by eliminating in advance those cell lines that have either no expression data or no sensitivity data. This step has the added benefit, as implemented, of aligning our sensitivity and gene-expression matrices so their columns correspond to the same cell-line identities as each other, in the same order.

50. An important idea in correlation analysis is that a gene whose expression correlates with small-molecule sensitivity has sufficient dynamic range to qualify as a potentially useful biomarker. Strong correlations with low effect sizes are less interesting. In practice, we save computation time by ruling out genes with low dynamic ranges in advance of computing correlations, but after the set of cell lines under consideration is known.

51. An important idea in correlation analysis is that compounds under consideration evince differential sensitivity across a set of cell lines, related to the idea of the “therapeutic window” between efficacy and toxicity. In practice, we save computation time by ruling out compounds with low dynamic ranges (or with little killing at all) in advance of computing correlations, but after the set of cell lines under consideration is known.

52. We choose 12 random compounds, strictly to keep demonstration run-times low (see also Note 32).

53. The primary correlation analysis at this stage is to perform many pairwise correlations between compound sensitivities and gene-expression levels. While we do take advantage of MATLAB’s powerful built-in pairwise similarity infrastructure, we note that accounting for missing values requires that we normalize correlation coefficients using Fisher’s z-transformation [37] to account for different numbers of cell lines participating in different comparisons. We implement these steps using the custom function nanpw2fishz.m and custom distance measure nanpwcor.m. We recommend studying the documentation within these two functions to learn how they operate in detail.

54. Since the output of nanpw2fishz.m is still a (potentially large) matrix of sensitivity-expression cross-correlations, we perform initial basic statistical filtering here, separately from quality-control filtering conducted downstream (in contrast to Procedure 2, where we performed both together).

55. We deliberately refrain from resolving compound and gene identifiers to human-readable names at this stage (see also Note 40).

56. For use in later visualizations, we record several (non-independent) expressions of the correlation, including the number of cell lines involved, the raw correlation coefficient, the correlation z-score from Fisher’s z-transformation [37], and a p-value derived from the Fisher’s z-transformation.

57. Experience has shown that statistical significance of a correlation result is necessary but not sufficient to warrant continued biological interest. Accordingly, we apply several additional filters on results to be output, including a minimum of 8 involved cell lines in the reference code (a relatively arbitrary value that is easy to modify). Most importantly, we have previously noticed many cases where a single cell line is responsible for the dynamic range of either sensitivity or gene-expression levels, and we are wary of investing much energy on such results even if their nominal p-values appear satisfactory. For nominally significant results, therefore, we censor the most extreme-valued cell line at each end of both the sensitivity and gene-expression distributions, then re-check whether the dynamic range of each vector satisfies our original criteria (see also Note 50 and Note 51). To ensure that the code produces at least one output for visualization, the correlation with the best p-value is retained, even if it fails these additional criteria.

58. With the extensive pre-filtering of correlation results based on dynamic-range considerations, the selection of data for visualization simply takes the largest raw (absolute) correlation coefficient result remaining after applying the filters (see also Note 39).

59. We note that human-readable context names are procured for use in the visualization directly from the result table in this case, while compound and gene names are procured from the master metadata (see also Note 40 and Note 55).

60. The figure code is deliberately included in the calling script master.m (see also Note 23).