Upload 1548 files

.gitattributes

@@ -33,3 +33,15 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+deepchem/source/contrib/dragonn/tutorial_images/dnn_figure.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/contrib/dragonn/tutorial_images/sequence_simulations.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/notebooks/assets/GraphConvArch.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/notebooks/assets/lime_dog.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/tutorials/assets/adc_components.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/tutorials/assets/ADCNet_2.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/tutorials/assets/generations_adc.jpg filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/tutorials/assets/lime_dog.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/tutorials/assets/trident_chemwidgets_data/Histogram.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/tutorials/assets/trident_chemwidgets_data/InteractiveMolecule.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/tutorials/assets/trident_chemwidgets_data/JSME.png filter=lfs diff=lfs merge=lfs -text
+deepchem/source/examples/tutorials/assets/trident_chemwidgets_data/Scatter.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10
+
+RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
+
+EXPOSE 7860
+
+CMD ["python", "deepchem/mcp_output/start_mcp.py"]

app.py

@@ -0,0 +1,45 @@
+from fastapi import FastAPI
+import os
+import sys
+
+mcp_plugin_path = os.path.join(os.path.dirname(__file__), "deepchem", "mcp_output", "mcp_plugin")
+sys.path.insert(0, mcp_plugin_path)
+
+app = FastAPI(
+    title="Deepchem MCP Service",
+    description="Auto-generated MCP service for deepchem",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "service": "Deepchem MCP Service",
+        "version": "1.0.0",
+        "status": "running",
+        "transport": os.environ.get("MCP_TRANSPORT", "http")
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "service": "deepchem MCP"}
+
+@app.get("/tools")
+def list_tools():
+    try:
+        from mcp_service import create_app
+        mcp_app = create_app()
+        tools = []
+        for tool_name, tool_func in mcp_app.tools.items():
+            tools.append({
+                "name": tool_name,
+                "description": tool_func.__doc__ or "No description available"
+            })
+        return {"tools": tools}
+    except Exception as e:
+        return {"error": f"Failed to load tools: {str(e)}"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

deepchem/mcp_output/README_MCP.md

@@ -0,0 +1,118 @@
+# DeepChem MCP (Model Context Protocol) Service README
+
+## 1) Project Introduction
+
+This MCP (Model Context Protocol) service wraps core DeepChem capabilities for molecular ML workflows, including:
+
+- Dataset loading and preprocessing (CSV/SDF/JSON/image/biological sequence)
+- Featurization (ECFP, graph, SMILES/token, protein/complex features)
+- Model training/inference (Torch, TensorFlow, JAX, sklearn, XGBoost)
+- Benchmarking via MolNet loaders and benchmark runners
+- Evaluation, metrics, splitting, transforms, and utility workflows
+
+Repository: https://github.com/deepchem/deepchem
+
+---
+
+## 2) Installation
+
+### Base requirements
+- Python 3.8+ (recommended 3.10/3.11)
+- Core libs: `numpy scipy pandas scikit-learn joblib tqdm`
+
+Install core package:
+- `pip install deepchem`
+
+Install optional stacks as needed:
+- Chemistry: `rdkit`
+- Deep learning: `torch` or `tensorflow` or `jax`
+- Extras: `pytorch-lightning transformers dgl torch-geometric xgboost lightgbm pyscf`
+
+Practical setup pattern:
+1. Create a fresh virtual environment
+2. Install `deepchem`
+3. Add only the backend/features you need (Torch/TensorFlow/JAX + RDKit)
+
+---
+
+## 3) Quick Start
+
+### Typical MCP (Model Context Protocol) flow
+1. Load dataset from MolNet (e.g., Tox21, Delaney, QM9)
+2. Apply featurizer and split strategy
+3. Train selected model
+4. Evaluate with DeepChem metrics
+5. Return scores/predictions via MCP (Model Context Protocol) response
+
+### Example task patterns
+- Classification benchmark: use `deepchem.molnet.run_benchmark`
+- Low-data benchmark: use `deepchem.molnet.run_benchmark_low_data`
+- Programmatic loading: use `deepchem.molnet.load_function.*`
+- Data ingest: `deepchem.data.*` loaders
+- Feature extraction: `deepchem.feat.*`
+- Training APIs: `deepchem.models.*` / `deepchem.models.torch_models.*`
+- Evaluation: `deepchem.metrics.*`, `deepchem.utils.evaluate`
+
+---
+
+## 4) Available Tools and Endpoints
+
+Recommended MCP (Model Context Protocol) service endpoints:
+
+- `health_check`
+  - Verify runtime, backend availability, and import status.
+
+- `list_capabilities`
+  - Return installed backends/features (Torch/TF/JAX/RDKit, etc.).
+
+- `load_dataset`
+  - Load datasets via MolNet (`load_tox21`, `load_delaney`, `load_qm9`, etc.) or file loaders.
+
+- `featurize_data`
+  - Apply selected featurizer (ECFP, graph conv, SMILES tokenizer, protein/complex, material).
+
+- `split_dataset`
+  - Apply splitters (random, scaffold, stratified, time/PDBBind, task-based).
+
+- `train_model`
+  - Train model families (GraphConv, MPNN, GCN/GAT, multitask MLP, sklearn, GBDT).
+
+- `predict`
+  - Run inference on prepared datasets.
+
+- `evaluate_model`
+  - Compute metrics (ROC-AUC, PRC-AUC, RMSE, MAE, Pearson R², etc.).
+
+- `run_benchmark`
+  - Execute MolNet benchmark workflow using selected model/split/featurizer.
+
+- `run_low_data_benchmark`
+  - Execute low-data benchmark variants.
+
+- `export_results`
+  - Save predictions, scores, and metadata to disk/artifact storage.
+
+---
+
+## 5) Common Issues and Notes
+
+- Dependency complexity is medium/high; install only required optional stacks.
+- RDKit is essential for many molecule features and loaders.
+- Torch/TF/JAX features are backend-specific; missing backend causes import/runtime failures.
+- Some benchmark datasets require downloading large files; expect longer setup times.
+- GPU acceleration depends on correct CUDA/backend build compatibility.
+- DGL/PyG-based models need matching versions with your PyTorch installation.
+- For reproducibility, set random seeds and pin package versions.
+
+---
+
+## 6) References
+
+- DeepChem repository: https://github.com/deepchem/deepchem
+- Main package docs (in repo): `README.md`, `docs/`
+- Examples: `examples/`
+- MolNet loaders: `deepchem/molnet/load_function/`
+- Benchmarks:  
+  - `python -m deepchem.molnet.run_benchmark`  
+  - `python -m deepchem.molnet.run_benchmark_low_data`
+- Contribution guide: `CONTRIBUTING.md`

deepchem/mcp_output/diff_report.md

@@ -0,0 +1,150 @@
+# Difference Report — `deepchem`
+
+**Generated:** 2026-03-14 11:47:54  
+**Repository:** `deepchem`  
+**Project Type:** Python library  
+**Scope:** Basic functionality  
+**Change Intrusiveness:** None  
+**Workflow Status:** ✅ Success  
+**Test Status:** ❌ Failed  
+**Files Changed:** 8 added, 0 modified, 0 deleted
+
+---
+
+## 1) Project Overview
+
+This update introduces **8 new files** without modifying existing code, indicating a **non-intrusive additive change set**. The CI/workflow completed successfully, but test execution failed, signaling potential issues in test configuration, environment compatibility, or missing integration logic for newly added assets.
+
+---
+
+## 2) High-Level Difference Summary
+
+| Metric | Value |
+|---|---|
+| New files | 8 |
+| Modified files | 0 |
+| Deleted files | 0 |
+| Intrusiveness | None (additive only) |
+| Workflow result | Success |
+| Test result | Failed |
+
+**Interpretation:**  
+- The change is structurally safe (no in-place modifications), reducing regression risk for existing core paths.  
+- The failed test status is the primary release blocker.
+
+---
+
+## 3) Difference Analysis
+
+### What changed
+- Added 8 files to the repository.
+- No existing source files were edited.
+
+### Likely impact areas
+Given a Python library context and “basic functionality” scope, new files commonly fall into:
+- new module/package entries,
+- helper utilities,
+- tests or fixtures,
+- docs/config metadata.
+
+### Risk profile
+- **Runtime risk:** Low to medium (depends on whether new files are imported by default).
+- **Compatibility risk:** Medium (if packaging or import paths are affected).
+- **Quality gate risk:** High due to test failure.
+
+---
+
+## 4) Technical Analysis
+
+## CI/Workflow
+- Workflow passed, indicating:
+  - syntax/lint/build stages likely successful,
+  - pipeline orchestration healthy.
+
+## Testing
+- Test suite failed despite workflow success.
+- Typical causes in additive-only updates:
+  1. New tests introduced but failing assertions.
+  2. Environment/dependency mismatch (e.g., optional deps not installed in test matrix).
+  3. Discovery/import issues from new package structure.
+  4. Version pin conflicts or platform-specific flaky behavior.
+
+## Packaging/Import Considerations
+For Python libraries, adding files can still impact:
+- package discovery (`setuptools.find_packages`, `pyproject.toml`, MANIFEST rules),
+- namespace/package `__init__.py` behavior,
+- relative imports and module resolution in tests.
+
+---
+
+## 5) Recommendations & Improvements
+
+## Immediate (Blocker Resolution)
+1. **Collect failing test logs** and classify failures:
+   - assertion failure vs import error vs environment error.
+2. **Reproduce locally** with same Python/test matrix as CI.
+3. **Validate package inclusion**:
+   - ensure new modules are included in build/wheel/sdist.
+4. **Check dependency constraints**:
+   - lock/relax pins as needed for test environment.
+5. **Rerun targeted tests**, then full suite.
+
+## Quality Enhancements
+- Add/verify:
+  - smoke tests for newly added functionality,
+  - import tests for new modules,
+  - minimal integration tests for exposed APIs.
+- If failures are flaky:
+  - isolate nondeterministic tests,
+  - seed randomness and stabilize fixtures.
+
+## Process Improvements
+- Require a **“tests pass” gate** before merge/release.
+- Add PR template fields:
+  - “new files added,”
+  - “packaging impact,”
+  - “test matrix validated.”
+
+---
+
+## 6) Deployment Information
+
+## Current readiness
+- **Not deployment-ready** due to failed tests.
+
+## Suggested release posture
+- **Hold release** until:
+  - all tests pass in primary CI matrix,
+  - new files verified in package artifacts,
+  - changelog/release notes updated.
+
+## Verification checklist before deploy
+- [ ] Full test suite green  
+- [ ] Wheel/sdist contain intended new files  
+- [ ] Import sanity checks pass (`import deepchem...`)  
+- [ ] Basic functionality smoke-tested in clean environment  
+- [ ] Versioning/release notes finalized  
+
+---
+
+## 7) Future Planning
+
+## Short-term (next iteration)
+- Resolve test failures and backfill missing tests around the added files.
+- Add CI job for packaging validation (`build` + artifact inspection).
+
+## Mid-term
+- Expand compatibility matrix (Python versions/platforms) if not already covered.
+- Add lightweight contract tests for public APIs to prevent silent breakage from additive changes.
+
+## Long-term
+- Establish change-risk tiers:
+  - additive-only, internal refactor, public API impact,
+  - each with required test/approval thresholds.
+- Improve observability in CI with clearer failure categorization dashboards.
+
+---
+
+## 8) Executive Conclusion
+
+This change set is **structurally low-risk** (8 new files, no modifications), but the **failed test status is a hard blocker**. Prioritize diagnosing and fixing test failures, verify packaging/import behavior for the new files, and rerun the complete CI matrix before deployment. Once tests are green, this update should be safe to release under a standard minor/internal update process.

deepchem/mcp_output/mcp_plugin/adapter.py

@@ -0,0 +1,481 @@
+import os
+import sys
+import importlib
+from typing import Any, Dict, List, Optional, Tuple
+
+source_path = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+    "source",
+)
+sys.path.insert(0, source_path)
+
+
+class Adapter:
+    """
+    Import-mode adapter for selected DeepChem repository modules.
+
+    This adapter attempts to import and call concrete implementations discovered
+    in repository analysis. It exposes:
+    - Function wrappers for identified callable functions.
+    - Class instance constructors for identified classes.
+    - CLI fallback helpers when import path execution is not available.
+
+    All methods return a unified dictionary with at least:
+    {
+        "status": "success" | "error" | "fallback",
+        ...
+    }
+    """
+
+    def __init__(self) -> None:
+        self.mode = "import"
+        self._modules: Dict[str, Any] = {}
+        self._class_instances: Dict[str, Any] = {}
+        self._import_errors: Dict[str, str] = {}
+        self._load_modules()
+
+    # -------------------------------------------------------------------------
+    # Internal utilities
+    # -------------------------------------------------------------------------
+    def _result(self, status: str, **kwargs: Any) -> Dict[str, Any]:
+        payload = {"status": status}
+        payload.update(kwargs)
+        return payload
+
+    def _import_module(self, module_path: str) -> Optional[Any]:
+        try:
+            module = importlib.import_module(module_path)
+            self._modules[module_path] = module
+            return module
+        except Exception as exc:
+            self._import_errors[module_path] = (
+                f"Failed to import '{module_path}'. "
+                f"Verify dependencies and source path. Details: {exc}"
+            )
+            return None
+
+    def _load_modules(self) -> None:
+        module_paths = [
+            "datasets.construct_pdbbind_df",
+            "docs.source.conf",
+            "contrib.visualization.utils",
+            "contrib.DeepMHC.bd13_datasets",
+            "contrib.DeepMHC.deepmhc",
+            "contrib.dragonn.models",
+        ]
+        for mp in module_paths:
+            self._import_module(mp)
+
+    def health_check(self) -> Dict[str, Any]:
+        """
+        Report adapter readiness and import status.
+
+        Returns:
+            Dict with loaded modules and import errors.
+        """
+        return self._result(
+            "success",
+            mode=self.mode,
+            loaded_modules=sorted(self._modules.keys()),
+            import_errors=self._import_errors,
+            guidance=(
+                "Install optional scientific dependencies (e.g., rdkit, tensorflow, torch) "
+                "if specific modules fail to import."
+            ),
+        )
+
+    def _call_function(
+        self,
+        module_path: str,
+        function_name: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        module = self._modules.get(module_path)
+        if module is None:
+            msg = self._import_errors.get(
+                module_path,
+                f"Module '{module_path}' is not available.",
+            )
+            return self._result(
+                "fallback",
+                error=msg,
+                guidance=(
+                    f"Cannot call '{function_name}' because import failed. "
+                    "Check Python path and install missing dependencies."
+                ),
+            )
+        fn = getattr(module, function_name, None)
+        if fn is None:
+            return self._result(
+                "error",
+                error=f"Function '{function_name}' not found in module '{module_path}'.",
+                guidance="Verify repository version and function name.",
+            )
+        try:
+            data = fn(*args, **kwargs)
+            return self._result(
+                "success",
+                module=module_path,
+                function=function_name,
+                data=data,
+            )
+        except Exception as exc:
+            return self._result(
+                "error",
+                error=f"Function call failed: {exc}",
+                guidance="Validate function parameters and input data format.",
+            )
+
+    def _create_instance(
+        self,
+        module_path: str,
+        class_name: str,
+        instance_key: Optional[str] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        module = self._modules.get(module_path)
+        if module is None:
+            msg = self._import_errors.get(
+                module_path,
+                f"Module '{module_path}' is not available.",
+            )
+            return self._result(
+                "fallback",
+                error=msg,
+                guidance=(
+                    f"Cannot instantiate '{class_name}' because import failed. "
+                    "Check dependency installation."
+                ),
+            )
+        cls = getattr(module, class_name, None)
+        if cls is None:
+            return self._result(
+                "error",
+                error=f"Class '{class_name}' not found in module '{module_path}'.",
+                guidance="Verify repository version and class name.",
+            )
+        try:
+            instance = cls(*args, **kwargs)
+            key = instance_key or f"{module_path}.{class_name}"
+            self._class_instances[key] = instance
+            return self._result(
+                "success",
+                module=module_path,
+                class_name=class_name,
+                instance_key=key,
+            )
+        except Exception as exc:
+            return self._result(
+                "error",
+                error=f"Class instantiation failed: {exc}",
+                guidance="Check constructor arguments and required runtime dependencies.",
+            )
+
+    # -------------------------------------------------------------------------
+    # Functions: datasets.construct_pdbbind_df
+    # -------------------------------------------------------------------------
+    def call_construct_df(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call datasets.construct_pdbbind_df.construct_df.
+
+        Parameters:
+            *args: Positional arguments forwarded to construct_df.
+            **kwargs: Keyword arguments forwarded to construct_df.
+
+        Returns:
+            Unified status dictionary with function output in 'data' on success.
+        """
+        return self._call_function("datasets.construct_pdbbind_df", "construct_df", *args, **kwargs)
+
+    def call_extract_labels(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call datasets.construct_pdbbind_df.extract_labels.
+
+        Parameters:
+            *args: Positional arguments forwarded to extract_labels.
+            **kwargs: Keyword arguments forwarded to extract_labels.
+
+        Returns:
+            Unified status dictionary with function output in 'data' on success.
+        """
+        return self._call_function("datasets.construct_pdbbind_df", "extract_labels", *args, **kwargs)
+
+    # -------------------------------------------------------------------------
+    # Functions: docs.source.conf
+    # -------------------------------------------------------------------------
+    def call_linkcode_resolve(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call docs.source.conf.linkcode_resolve.
+
+        Parameters:
+            *args: Positional arguments forwarded to linkcode_resolve.
+            **kwargs: Keyword arguments forwarded to linkcode_resolve.
+
+        Returns:
+            Unified status dictionary with resolved link info in 'data' on success.
+        """
+        return self._call_function("docs.source.conf", "linkcode_resolve", *args, **kwargs)
+
+    # -------------------------------------------------------------------------
+    # Functions: contrib.visualization.utils
+    # -------------------------------------------------------------------------
+    def call_combine_mdtraj(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call contrib.visualization.utils.combine_mdtraj.
+
+        Parameters:
+            *args: Positional arguments forwarded to combine_mdtraj.
+            **kwargs: Keyword arguments forwarded to combine_mdtraj.
+
+        Returns:
+            Unified status dictionary containing result in 'data' on success.
+        """
+        return self._call_function("contrib.visualization.utils", "combine_mdtraj", *args, **kwargs)
+
+    def call_convert_lines_to_mdtraj(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call contrib.visualization.utils.convert_lines_to_mdtraj.
+
+        Parameters:
+            *args: Positional arguments forwarded to convert_lines_to_mdtraj.
+            **kwargs: Keyword arguments forwarded to convert_lines_to_mdtraj.
+
+        Returns:
+            Unified status dictionary containing result in 'data' on success.
+        """
+        return self._call_function("contrib.visualization.utils", "convert_lines_to_mdtraj", *args, **kwargs)
+
+    def call_display_images(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call contrib.visualization.utils.display_images.
+
+        Parameters:
+            *args: Positional arguments forwarded to display_images.
+            **kwargs: Keyword arguments forwarded to display_images.
+
+        Returns:
+            Unified status dictionary containing result in 'data' on success.
+        """
+        return self._call_function("contrib.visualization.utils", "display_images", *args, **kwargs)
+
+    # -------------------------------------------------------------------------
+    # Functions: contrib.DeepMHC.bd13_datasets
+    # -------------------------------------------------------------------------
+    def call_featurize(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call contrib.DeepMHC.bd13_datasets.featurize.
+
+        Parameters:
+            *args: Positional arguments forwarded to featurize.
+            **kwargs: Keyword arguments forwarded to featurize.
+
+        Returns:
+            Unified status dictionary containing featurized output in 'data' on success.
+        """
+        return self._call_function("contrib.DeepMHC.bd13_datasets", "featurize", *args, **kwargs)
+
+    def call_load_bd2013_human(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call contrib.DeepMHC.bd13_datasets.load_bd2013_human.
+
+        Parameters:
+            *args: Positional arguments forwarded to load_bd2013_human.
+            **kwargs: Keyword arguments forwarded to load_bd2013_human.
+
+        Returns:
+            Unified status dictionary with loaded dataset artifacts in 'data' on success.
+        """
+        return self._call_function("contrib.DeepMHC.bd13_datasets", "load_bd2013_human", *args, **kwargs)
+
+    def call_to_one_hot_array(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Call contrib.DeepMHC.bd13_datasets.to_one_hot_array.
+
+        Parameters:
+            *args: Positional arguments forwarded to to_one_hot_array.
+            **kwargs: Keyword arguments forwarded to to_one_hot_array.
+
+        Returns:
+            Unified status dictionary with encoded array in 'data' on success.
+        """
+        return self._call_function("contrib.DeepMHC.bd13_datasets", "to_one_hot_array", *args, **kwargs)
+
+    # -------------------------------------------------------------------------
+    # Classes: contrib.DeepMHC.deepmhc.DeepMHC
+    # -------------------------------------------------------------------------
+    def create_deepmhc(self, *args: Any, instance_key: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Instantiate contrib.DeepMHC.deepmhc.DeepMHC.
+
+        Parameters:
+            *args: Positional constructor args.
+            instance_key: Optional storage key for later retrieval.
+            **kwargs: Keyword constructor args.
+
+        Returns:
+            Unified status dictionary with 'instance_key' on success.
+        """
+        return self._create_instance(
+            "contrib.DeepMHC.deepmhc",
+            "DeepMHC",
+            instance_key,
+            *args,
+            **kwargs,
+        )
+
+    # -------------------------------------------------------------------------
+    # Classes: contrib.dragonn.models
+    # -------------------------------------------------------------------------
+    def create_motif_score_rnn(self, *args: Any, instance_key: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Instantiate contrib.dragonn.models.MotifScoreRNN.
+
+        Parameters:
+            *args: Positional constructor args.
+            instance_key: Optional storage key for later retrieval.
+            **kwargs: Keyword constructor args.
+
+        Returns:
+            Unified status dictionary with 'instance_key' on success.
+        """
+        return self._create_instance(
+            "contrib.dragonn.models",
+            "MotifScoreRNN",
+            instance_key,
+            *args,
+            **kwargs,
+        )
+
+    def create_gkmsvm(self, *args: Any, instance_key: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
+        """
+        Instantiate contrib.dragonn.models.gkmSVM.
+
+        Parameters:
+            *args: Positional constructor args.
+            instance_key: Optional storage key for later retrieval.
+            **kwargs: Keyword constructor args.
+
+        Returns:
+            Unified status dictionary with 'instance_key' on success.
+        """
+        return self._create_instance(
+            "contrib.dragonn.models",
+            "gkmSVM",
+            instance_key,
+            *args,
+            **kwargs,
+        )
+
+    # -------------------------------------------------------------------------
+    # Instance management
+    # -------------------------------------------------------------------------
+    def list_instances(self) -> Dict[str, Any]:
+        """
+        List cached class instances created by this adapter.
+
+        Returns:
+            Unified status dictionary containing instance keys.
+        """
+        return self._result("success", instances=sorted(self._class_instances.keys()))
+
+    def call_instance_method(
+        self,
+        instance_key: str,
+        method_name: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """
+        Invoke a method on a previously created instance.
+
+        Parameters:
+            instance_key: Key returned by create_* method.
+            method_name: Target method name on the instance.
+            *args: Positional arguments for the instance method.
+            **kwargs: Keyword arguments for the instance method.
+
+        Returns:
+            Unified status dictionary with method result in 'data' on success.
+        """
+        inst = self._class_instances.get(instance_key)
+        if inst is None:
+            return self._result(
+                "error",
+                error=f"Instance '{instance_key}' not found.",
+                guidance="Create the instance first using the matching create_* method.",
+            )
+        method = getattr(inst, method_name, None)
+        if method is None or not callable(method):
+            return self._result(
+                "error",
+                error=f"Method '{method_name}' not found on instance '{instance_key}'.",
+                guidance="Check available methods with dir(instance).",
+            )
+        try:
+            data = method(*args, **kwargs)
+            return self._result("success", instance_key=instance_key, method=method_name, data=data)
+        except Exception as exc:
+            return self._result(
+                "error",
+                error=f"Instance method call failed: {exc}",
+                guidance="Validate method parameters and ensure model state is initialized.",
+            )
+
+    # -------------------------------------------------------------------------
+    # CLI fallback helpers
+    # -------------------------------------------------------------------------
+    def cli_run_benchmark(self, extra_args: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Provide CLI fallback guidance for MolNet benchmark execution.
+
+        Parameters:
+            extra_args: Optional CLI args to append.
+
+        Returns:
+            Unified status dictionary with a suggested command.
+        """
+        cmd = ["python", "-m", "source.deepchem.molnet.run_benchmark"] + (extra_args or [])
+        return self._result(
+            "fallback",
+            command=cmd,
+            guidance=(
+                "Use this command in a shell when import-mode execution is unavailable. "
+                "Ensure dependencies are installed and run from project root."
+            ),
+        )
+
+    def cli_run_benchmark_low_data(self, extra_args: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Provide CLI fallback guidance for low-data benchmark workflow.
+
+        Parameters:
+            extra_args: Optional CLI args to append.
+
+        Returns:
+            Unified status dictionary with a suggested command.
+        """
+        cmd = ["python", "-m", "source.deepchem.molnet.run_benchmark_low_data"] + (extra_args or [])
+        return self._result(
+            "fallback",
+            command=cmd,
+            guidance="Run in shell as fallback. Verify low-data benchmark options before execution.",
+        )
+
+    def cli_run_example_benchmark(self, extra_args: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Provide CLI fallback guidance for example benchmark runner.
+
+        Parameters:
+            extra_args: Optional CLI args to append.
+
+        Returns:
+            Unified status dictionary with a suggested command.
+        """
+        cmd = ["python", "-m", "source.examples.benchmark"] + (extra_args or [])
+        return self._result(
+            "fallback",
+            command=cmd,
+            guidance="This is a demo-oriented runner and may be less stable than core benchmark scripts.",
+        )

deepchem/mcp_output/mcp_plugin/main.py

@@ -0,0 +1,13 @@
+"""
+MCP Service Auto-Wrapper - Auto-generated
+"""
+from mcp_service import create_app
+
+def main():
+    """Main entry point"""
+    app = create_app()
+    return app
+
+if __name__ == "__main__":
+    app = main()
+    app.run()

deepchem/mcp_output/mcp_plugin/mcp_service.py

@@ -0,0 +1,240 @@
+import os
+import sys
+
+source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
+if source_path not in sys.path:
+    sys.path.insert(0, source_path)
+
+from fastmcp import FastMCP
+
+from datasets.construct_pdbbind_df import construct_df, extract_labels
+from docs.source.conf import linkcode_resolve
+from contrib.visualization.utils import combine_mdtraj, display_images, convert_lines_to_mdtraj
+from contrib.DeepMHC.bd13_datasets import load_bd2013_human, to_one_hot_array, featurize
+from contrib.DeepMHC.deepmhc import DeepMHC
+from contrib.dragonn.models import MotifScoreRNN, gkmSVM
+
+mcp = FastMCP("unknown_service")
+
+
+@mcp.tool(name="construct_df", description="Auto-wrapped function construct_df")
+def construct_df(payload: dict):
+    try:
+        if construct_df is None:
+            return {"success": False, "result": None, "error": "Function construct_df is not available"}
+        result = construct_df(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="extract_labels", description="Auto-wrapped function extract_labels")
+def extract_labels(payload: dict):
+    try:
+        if extract_labels is None:
+            return {"success": False, "result": None, "error": "Function extract_labels is not available"}
+        result = extract_labels(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="linkcode_resolve", description="Auto-wrapped function linkcode_resolve")
+def linkcode_resolve(payload: dict):
+    try:
+        if linkcode_resolve is None:
+            return {"success": False, "result": None, "error": "Function linkcode_resolve is not available"}
+        result = linkcode_resolve(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="combine_mdtraj", description="Auto-wrapped function combine_mdtraj")
+def combine_mdtraj(payload: dict):
+    try:
+        if combine_mdtraj is None:
+            return {"success": False, "result": None, "error": "Function combine_mdtraj is not available"}
+        result = combine_mdtraj(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="convert_lines_to_mdtraj", description="Auto-wrapped function convert_lines_to_mdtraj")
+def convert_lines_to_mdtraj(payload: dict):
+    try:
+        if convert_lines_to_mdtraj is None:
+            return {"success": False, "result": None, "error": "Function convert_lines_to_mdtraj is not available"}
+        result = convert_lines_to_mdtraj(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="display_images", description="Auto-wrapped function display_images")
+def display_images(payload: dict):
+    try:
+        if display_images is None:
+            return {"success": False, "result": None, "error": "Function display_images is not available"}
+        result = display_images(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="featurize", description="Auto-wrapped function featurize")
+def featurize(payload: dict):
+    try:
+        if featurize is None:
+            return {"success": False, "result": None, "error": "Function featurize is not available"}
+        result = featurize(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="load_bd2013_human", description="Auto-wrapped function load_bd2013_human")
+def load_bd2013_human(payload: dict):
+    try:
+        if load_bd2013_human is None:
+            return {"success": False, "result": None, "error": "Function load_bd2013_human is not available"}
+        result = load_bd2013_human(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="to_one_hot_array", description="Auto-wrapped function to_one_hot_array")
+def to_one_hot_array(payload: dict):
+    try:
+        if to_one_hot_array is None:
+            return {"success": False, "result": None, "error": "Function to_one_hot_array is not available"}
+        result = to_one_hot_array(**payload)
+        return {"success": True, "result": result, "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="deepmhc", description="DeepMHC class")
+def deepmhc(*args, **kwargs):
+    """DeepMHC class"""
+    try:
+        if DeepMHC is None:
+            return {"success": False, "result": None, "error": "Class DeepMHC is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = DeepMHC(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="motifscorernn", description="MotifScoreRNN class")
+def motifscorernn(*args, **kwargs):
+    """MotifScoreRNN class"""
+    try:
+        if MotifScoreRNN is None:
+            return {"success": False, "result": None, "error": "Class MotifScoreRNN is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = MotifScoreRNN(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="gkmsvm", description="gkmSVM class")
+def gkmsvm(*args, **kwargs):
+    """gkmSVM class"""
+    try:
+        if gkmSVM is None:
+            return {"success": False, "result": None, "error": "Class gkmSVM is not available, path may need adjustment"}
+        
+        # MCP parameter type conversion
+        converted_args = []
+        converted_kwargs = kwargs.copy()
+        
+        # Handle position argument type conversion
+        for arg in args:
+            if isinstance(arg, str):
+                # Try to convert to numeric type
+                try:
+                    if '.' in arg:
+                        converted_args.append(float(arg))
+                    else:
+                        converted_args.append(int(arg))
+                except ValueError:
+                    converted_args.append(arg)
+            else:
+                converted_args.append(arg)
+        
+        # Handle keyword argument type conversion
+        for key, value in converted_kwargs.items():
+            if isinstance(value, str):
+                try:
+                    if '.' in value:
+                        converted_kwargs[key] = float(value)
+                    else:
+                        converted_kwargs[key] = int(value)
+                except ValueError:
+                    pass
+        
+        instance = gkmSVM(*converted_args, **converted_kwargs)
+        return {"success": True, "result": str(instance), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
+
+def create_app():
+    """Create and return FastMCP application instance"""
+    return mcp
+
+if __name__ == "__main__":
+    mcp.run(transport="http", host="0.0.0.0", port=8000)

deepchem/mcp_output/requirements.txt

@@ -0,0 +1,13 @@
+fastmcp
+fastapi
+uvicorn[standard]
+pydantic>=2.0.0
+joblib
+numpy<2
+pandas
+scikit-learn
+sympy
+scipy>=1.10.1
+rdkit
+numpy
+tqdm

deepchem/mcp_output/start_mcp.py

@@ -0,0 +1,30 @@
+
+"""
+MCP Service Startup Entry
+"""
+import sys
+import os
+
+project_root = os.path.dirname(os.path.abspath(__file__))
+mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
+if mcp_plugin_dir not in sys.path:
+    sys.path.insert(0, mcp_plugin_dir)
+
+from mcp_service import create_app
+
+def main():
+    """Start FastMCP service"""
+    app = create_app()
+    # Use environment variable to configure port, default 8000
+    port = int(os.environ.get("MCP_PORT", "8000"))
+    
+    # Choose transport mode based on environment variable
+    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+    if transport == "http":
+        app.run(transport="http", host="0.0.0.0", port=port)
+    else:
+        # Default to STDIO mode
+        app.run()
+
+if __name__ == "__main__":
+    main()

deepchem/mcp_output/workflow_summary.json

@@ -0,0 +1,251 @@
+{
+  "repository": {
+    "name": "deepchem",
+    "url": "https://github.com/deepchem/deepchem",
+    "local_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/deepchem",
+    "description": "Python library",
+    "features": "Basic functionality",
+    "tech_stack": "Python",
+    "stars": 0,
+    "forks": 0,
+    "language": "Python",
+    "last_updated": "",
+    "complexity": "complex",
+    "intrusiveness_risk": "medium"
+  },
+  "execution": {
+    "start_time": 1773459511.7688398,
+    "end_time": 1773459926.1967611,
+    "duration": 414.427921295166,
+    "status": "success",
+    "workflow_status": "success",
+    "nodes_executed": [
+      "download",
+      "analysis",
+      "env",
+      "generate",
+      "run",
+      "review",
+      "finalize"
+    ],
+    "total_files_processed": 24,
+    "environment_type": "unknown",
+    "llm_calls": 0,
+    "deepwiki_calls": 0
+  },
+  "tests": {
+    "original_project": {
+      "passed": false,
+      "details": {},
+      "test_coverage": "100%",
+      "execution_time": 0,
+      "test_files": []
+    },
+    "mcp_plugin": {
+      "passed": true,
+      "details": {},
+      "service_health": "healthy",
+      "startup_time": 0,
+      "transport_mode": "stdio",
+      "fastmcp_version": "unknown",
+      "mcp_version": "unknown"
+    }
+  },
+  "analysis": {
+    "structure": {
+      "packages": [
+        "deployment.deepchem.source",
+        "mcp_output.mcp_plugin",
+        "source.contrib.autoencoder_models",
+        "source.contrib.nn",
+        "source.contrib.tensorflow_models",
+        "source.deepchem",
+        "source.deepchem.data",
+        "source.deepchem.dock",
+        "source.deepchem.feat",
+        "source.deepchem.hyper",
+        "source.deepchem.metalearning",
+        "source.deepchem.metrics",
+        "source.deepchem.models",
+        "source.deepchem.molnet",
+        "source.deepchem.rl",
+        "source.deepchem.splits",
+        "source.deepchem.trans",
+        "source.deepchem.utils",
+        "source.examples.adme",
+        "source.examples.chembl",
+        "source.examples.clintox",
+        "source.examples.encoders",
+        "source.examples.low_data",
+        "source.examples.membrane_permeability"
+      ]
+    },
+    "dependencies": {
+      "has_environment_yml": false,
+      "has_requirements_txt": false,
+      "pyproject": false,
+      "setup_cfg": true,
+      "setup_py": true
+    },
+    "entry_points": {
+      "imports": [],
+      "cli": [],
+      "modules": []
+    },
+    "risk_assessment": {
+      "import_feasibility": 0.82,
+      "intrusiveness_risk": "medium",
+      "complexity": "complex"
+    },
+    "deepwiki_analysis": {
+      "repo_url": "https://github.com/deepchem/deepchem",
+      "repo_name": "deepchem",
+      "error": "DeepWiki analysis failed",
+      "model": "gpt-5.3-codex",
+      "source": "llm_direct_analysis",
+      "success": false
+    },
+    "code_complexity": {
+      "cyclomatic_complexity": "medium",
+      "cognitive_complexity": "medium",
+      "maintainability_index": 75
+    },
+    "security_analysis": {
+      "vulnerabilities_found": 0,
+      "security_score": 85,
+      "recommendations": []
+    }
+  },
+  "plugin_generation": {
+    "files_created": [
+      "mcp_output/start_mcp.py",
+      "mcp_output/mcp_plugin/__init__.py",
+      "mcp_output/mcp_plugin/mcp_service.py",
+      "mcp_output/mcp_plugin/adapter.py",
+      "mcp_output/mcp_plugin/main.py",
+      "mcp_output/requirements.txt",
+      "mcp_output/README_MCP.md"
+    ],
+    "main_entry": "start_mcp.py",
+    "requirements": [
+      "fastmcp>=0.1.0",
+      "pydantic>=2.0.0"
+    ],
+    "readme_path": "/Users/ghh/Documents/Code/Code2MCP-private/workspace/deepchem/mcp_output/README_MCP.md",
+    "adapter_mode": "import",
+    "total_lines_of_code": 0,
+    "generated_files_size": 0,
+    "tool_endpoints": 0,
+    "supported_features": [
+      "Basic functionality"
+    ],
+    "generated_tools": [
+      "Basic tools",
+      "Health check tools",
+      "Version info tools"
+    ]
+  },
+  "code_review": {},
+  "errors": [],
+  "warnings": [],
+  "recommendations": [
+    "add a minimal but real smoke-test suite (import core packages",
+    "run one tiny featurizer/model fit) since test status is empty",
+    "reduce MCP surface area by exposing only curated/stable endpoints (current list is excessively broad and risky)",
+    "introduce endpoint namespacing/versioning (e.g.",
+    "`models.train.v1`) and de-duplicate collisions like repeated `params`/`softmax`",
+    "add strict input/output schemas and runtime validation for every MCP endpoint (Pydantic models",
+    "bounds",
+    "enum constraints)",
+    "create a dependency-tier test matrix in CI (base",
+    "rdkit",
+    "torch",
+    "tensorflow",
+    "jax",
+    "optional extras) with clear required vs optional gating",
+    "publish a canonical `pyproject.toml` (while keeping setup.py compatibility if needed) and generate lockfiles for reproducible environments",
+    "add contract tests for plugin adapter mode (`import` fallback to `cli`) and failure-mode tests for missing optional deps",
+    "mark `contrib/` modules as experimental/legacy in docs and exclude them from default MCP export",
+    "prioritize refactoring oversized/high-churn files (`deepchem/models/torch_models/layers.py`",
+    "`deepchem/models/layers.py`",
+    "dataset utilities) into smaller modules with ownership",
+    "enforce type coverage on public APIs and MCP-exposed functions (mypy/pyright in CI)",
+    "add performance regression benchmarks for representative workloads (featurization",
+    "dataloading",
+    "torch training step)",
+    "improve observability with structured logs/error codes in MCP service and endpoint-level latency/error metrics",
+    "harden security by restricting filesystem/network-capable endpoints and adding allowlists/sandboxing for loader utilities",
+    "create a compatibility policy and deprecation workflow for renamed/removed endpoints",
+    "add golden integration tests for top CLI entry points (`run_benchmark`",
+    "low-data benchmark",
+    "example benchmark)",
+    "improve docs discoverability with a generated endpoint catalog (stable vs experimental",
+    "dependency requirements",
+    "examples)",
+    "add pre-commit rules for import hygiene/complexity thresholds to prevent further API sprawl",
+    "define a release checklist that includes MCP contract diff",
+    "dependency drift audit",
+    "and cross-backend smoke validation"
+  ],
+  "performance_metrics": {
+    "memory_usage_mb": 0,
+    "cpu_usage_percent": 0,
+    "response_time_ms": 0,
+    "throughput_requests_per_second": 0
+  },
+  "deployment_info": {
+    "supported_platforms": [
+      "Linux",
+      "Windows",
+      "macOS"
+    ],
+    "python_versions": [
+      "3.8",
+      "3.9",
+      "3.10",
+      "3.11",
+      "3.12"
+    ],
+    "deployment_methods": [
+      "Docker",
+      "pip",
+      "conda"
+    ],
+    "monitoring_support": true,
+    "logging_configuration": "structured"
+  },
+  "execution_analysis": {
+    "success_factors": [
+      "Workflow status is success with all planned nodes executed end-to-end (download, analysis, env, generate, run, review, finalize).",
+      "Import-first adapter strategy was feasible (import_feasibility 0.82) and MCP plugin started healthy over stdio.",
+      "Repository ingestion succeeded via zip fallback despite DeepWiki failure, allowing static AST-based discovery and generation.",
+      "No runtime errors or warnings were recorded in the workflow."
+    ],
+    "failure_reasons": [
+      "No hard workflow failure occurred.",
+      "Quality-gap failures: original project tests not executed/passed (reported passed=false with empty details) and MCP test evidence is minimal.",
+      "DeepWiki analysis failed, reducing external contextual enrichment.",
+      "Generated MCP surface appears over-broad and potentially noisy (very large endpoint list, collisions like repeated params/softmax)."
+    ],
+    "overall_assessment": "good",
+    "node_performance": {
+      "download_time": "Completed successfully; repository imported via zip fallback. No per-node timing provided, but download was not a blocker.",
+      "analysis_time": "Likely dominant phase due to AST scan across ~997 files and large symbol extraction; completed without errors.",
+      "generation_time": "Completed and produced 7 MCP artifacts; generation appears fast relative to deep analysis, but exact timing unavailable.",
+      "test_time": "Plugin health check passed, but substantive test execution is effectively absent (original tests empty), so validation depth is low."
+    },
+    "resource_usage": {
+      "memory_efficiency": "Unknown/insufficient telemetry (reported 0 MB). Instrumentation gap prevents assessment.",
+      "cpu_efficiency": "Unknown/insufficient telemetry (reported 0%). Instrumentation gap prevents assessment.",
+      "disk_usage": "Generated output footprint reported as 0 size/0 LOC, likely a metrics collection defect rather than true zero usage."
+    }
+  },
+  "technical_quality": {
+    "code_quality_score": 74,
+    "architecture_score": 78,
+    "performance_score": 62,
+    "maintainability_score": 70,
+    "security_score": 85,
+    "scalability_score": 68
+  }
+}

deepchem/source/.pre-commit-config.yaml

@@ -0,0 +1,25 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v3.4.0
+    hooks:
+      - id: check-merge-conflict
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+
+-   repo: https://github.com/pre-commit/mirrors-yapf
+    rev: v0.32.0
+    hooks:
+    -   id: yapf
+
+-   repo: https://github.com/PyCQA/flake8
+    rev: 3.8.4
+    hooks:
+    -   id: flake8
+        args: [--count]
+
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v0.790
+    hooks:
+    -   id: mypy
+        args: [--ignore-missing-imports]

deepchem/source/.readthedocs.yml

@@ -0,0 +1,23 @@
+# .readthedocs.yml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  configuration: docs/source/conf.py
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.9"
+
+# Optionally build your docs in additional formats such as PDF and ePub
+formats: all
+
+# Optionally set the version of Python and requirements required to build your docs
+python:
+  install:
+    - requirements: docs/requirements.txt

deepchem/source/.yapfignore

@@ -0,0 +1,2 @@
+#no need to format .npy files
+*.npy

deepchem/source/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at rbharath@stanford.edu. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

deepchem/source/CONTRIBUTING.md

@@ -0,0 +1,188 @@
+# Table of Contents
+
+<!-- toc -->
+- [Contributing to Deepchem](#contributing-to-deepchem)
+  - [Getting Started](#getting-started)
+  - [Pull Request Process](#pull-request-process)
+  - [Coding Conventions](#coding-conventions)
+  - [Documentation Conventions](#documentation-conventions)
+- [The Agreement](#the-agreement)
+- [Deepchem Technical Steering Committee](#deepchem-technical-steering-committee)
+<!-- tocstop -->
+
+## Contributing to DeepChem
+
+We actively encourage community contributions to DeepChem. The first
+place to start getting involved is
+[the tutorials](https://deepchem.readthedocs.io/en/latest/get_started/tutorials.html).
+Afterwards, we encourage contributors to give a shot to improving our documentation.
+While we take effort to provide good docs, there's plenty of room
+for improvement. All docs are hosted on Github, either in `README.md`
+file, or in the `docs/` directory.
+
+Once you've got a sense of how the package works, we encourage the use
+of Github issues to discuss more complex changes, raise requests for
+new features or propose changes to the global architecture of DeepChem.
+Once consensus is reached on the issue, please submit a PR with proposed
+modifications. All contributed code to DeepChem will be reviewed by a member
+of the DeepChem team, so please make sure your code style and documentation
+style match our guidelines!
+
+### Getting Started
+
+To develop DeepChem on your machine, we recommend using Anaconda for managing
+packages. If you want to manage multiple builds of DeepChem, you can make use of
+[conda environments](https://conda.io/projects/conda/en/latest/user-guide/concepts/environments.html)
+to maintain seperate Python package environments, each of which can be tied
+to a specific build of DeepChem. Here are some tips to get started:
+
+1. Fork the [DeepChem](https://github.com/deepchem/deepchem/) repository
+and clone the forked repository
+
+```bash
+git clone https://github.com/YOUR-USERNAME/deepchem.git
+cd deepchem
+```
+
+&nbsp;&nbsp;&nbsp;&nbsp; 1.1. If you already have DeepChem from source, update it by running
+```bash
+git fetch upstream
+git rebase upstream/master
+```
+
+2. Set up a new conda environment for DeepChem
+
+```bash
+conda create -n deepchem python=3.8
+conda activate deepchem
+```
+
+&nbsp;&nbsp;&nbsp;&nbsp; 2.1. DeepChem provides backend support for deep
+learning using tensorflow, pytorch or jax. By default, the deep learning frameworks
+gets installed in CPU. If GPU support is required, make sure CUDA is installed
+and then install the desired deep learning framework before installing DeepChem:
+- [tensorflow](https://www.tensorflow.org/install)
+- [pytorch](https://pytorch.org/get-started/locally/#start-locally)
+- [jax](https://github.com/google/jax#installation)
+
+3. Install DeepChem in `develop` mode
+
+```bash
+python setup.py develop
+```
+
+This mode will symlink the Python files from current local source tree into
+the Python install. Hence, if you modify a Python file, you do not need to
+reinstall DeepChem again and again.
+
+In case you need to reinstall, uninstall DeepChem first by running
+`pip uninstall deepchem` until you see `Warning: Skipping deepchem
+as it is not installed`; run `python setup.py clean` and install in `develop` mode again.
+
+Some other tips:
+- Every contribution must pass the unit tests. Some tests are
+[marked](https://docs.pytest.org/en/6.2.x/example/markers.html) with custom
+markers like `@pytest.mark.tensorflow`. This helps mainly in two ways: 1) restricting the tests only
+to the part of code marked with the marker 2) giving
+[flexibility](https://docs.pytest.org/en/6.2.x/example/markers.html) in running
+the unit tests depending on the environment.
+- DeepChem has a number of soft requirements which can be found [here](https://deepchem.readthedocs.io/en/latest/get_started/requirements.html).
+- If a commit is simple and doesn't affect any code (keep in mind that some
+docstrings contain code that is used in tests), you can add `[skip ci]`
+(case sensitive) somewhere in your commit message to [skip all build /
+test steps](https://github.blog/changelog/2021-02-08-github-actions-skip-pull-request-and-push-workflows-with-skip-ci/). Note that changing the pull request body or title on GitHub itself has no effect.
+
+
+### Pull Request Process
+
+Every contribution, must be a pull request and must have adequate time for
+review by other committers.
+
+A member of the Technical Steering Committee will review the pull request.
+The default path of every contribution should be to merge. The discussion,
+review, and merge process should be designed as corrections that move the
+contribution into the path to merge. Once there are no more corrections,
+(dissent) changes should merge without further process.
+
+On successful merge the author will be added as a member of the DeepChem organization.
+
+### Coding Conventions
+
+DeepChem uses these tools or styles for keeping our codes healthy.
+
+- [YAPF](https://github.com/google/yapf) (code format)
+- [Flake8](https://flake8.pycqa.org/en/latest/) (code style check)
+- [mypy](http://mypy-lang.org/) (type check)
+- [doctest](https://docs.python.org/3/library/doctest.html) (interactive examples)
+- [pytest](https://docs.pytest.org/en/6.2.x/index.html) (unit testing)
+
+Before making a PR, please check your codes using them.
+You can confirm how to check your codes from [Coding Conventions](https://deepchem.readthedocs.io/en/latest/development_guide/coding.html).
+
+### Document Conventions
+
+DeepChem uses [Sphinx](https://www.sphinx-doc.org/en/master/) to build
+[the document](https://deepchem.readthedocs.io/en/latest/index.html).
+The document is automatically built by
+[Numpy style docstrings](https://numpydoc.readthedocs.io/en/latest/format.html#numpydoc-docstring-guide)
+in source codes and [Napoleon extension](http://www.sphinx-doc.org/en/stable/ext/napoleon.html).
+For any changes or modification to source code in a PR, please don't forget to add or modify Numpy style docstrings.
+
+## The Agreement
+
+Contributor offers to license certain software (a “Contribution” or multiple
+“Contributions”) to DeepChem, and DeepChem agrees to accept said Contributions,
+under the terms of the open source license [The MIT License](https://opensource.org/licenses/MIT)
+
+The Contributor understands and agrees that DeepChem shall have the
+irrevocable and perpetual right to make and distribute copies of any Contribution, as
+well as to create and distribute collective works and derivative works of any Contribution,
+under [The MIT License](https://opensource.org/licenses/MIT).
+
+DeepChem understands and agrees that Contributor retains copyright in its Contributions.
+Nothing in this Contributor Agreement shall be interpreted to prohibit Contributor
+from licensing its Contributions under different terms from the
+[The MIT License](https://opensource.org/licenses/MIT) or this Contributor Agreement.
+
+## DeepChem Technical Steering Committee
+
+The Technical Steering Committee admits and oversees all top-level of DeepChem.
+
+The TSC exercises autonomy in setting up and maintaining procedures, policies,
+and management and administrative structures as it deems appropriate for the
+maintenance and operation of these projects and resources.
+
+Included in the responsibilities of the TSC are:
+
+* Managing code and documentation creation and changes for the listed projects and resources
+* Performing code reviews on incoming pull requests and merging suitable code changes.
+* Setting and maintaining standards covering contributions of code, documentation and other materials
+* Managing code and binary releases: types, schedules, frequency, delivery mechanisms
+* Making decisions regarding dependencies of DeepChem, including what those
+dependencies are and how they are bundled with source code and releases
+* Creating new repositories and projects under the deepchem GitHub organization as required
+* Setting overall technical direction for the DeepChem project, including 
+high-level goals and low-level specifics regarding features and functionality
+* Setting and maintaining appropriate standards for community discourse via the various
+mediums under TSC control (gitter, facebook, blog)
+
+Members of the TSC will meet regularly (over phone or video conferencing)
+to coordinate efforts. Minutes from the TSC meetings will be published publicly on an ongoing basis.
+The current members of the TSC are (alphabetically)
+* Peter Eastman
+* Karl Leswing
+* Bharath Ramsundar
+* Zhenqin Wu
+
+If you want to join the technical steering committee, you will need to
+submit an application. The application process is relatively lightweight: submit
+a one page document discussing your past contributions to DeepChem and
+propose potential projects you could commit to working on as a member of the
+steering committee. Note that steering committee membership comes with responsibilities.
+In particular, you will need to commit to spending about 10 hours a
+week working on DeepChem. The committee will review your application, and
+if suitable, will accept you as a probationary member of the TSC. Your
+application will be posted publicly to the DeepChem blog if accepted. Membership
+on the committee will be confirmed after 6 months if you’ve successfully
+implemented some of your proposed projects and demonstrated your ability
+to meet the necessary time commitment.

deepchem/source/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2017 PandeLab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

deepchem/source/README.md

@@ -0,0 +1,159 @@
+# DeepChem
+
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/deepchem/badges/version.svg)](https://anaconda.org/conda-forge/deepchem)
+[![PyPI version](https://badge.fury.io/py/deepchem.svg)](https://pypi.org/project/deepchem/)
+[![Documentation Status](https://readthedocs.org/projects/deepchem/badge/?version=latest)](https://deepchem.readthedocs.io/en/latest/?badge=latest)  
+[![Test for DeepChem Core](https://github.com/deepchem/deepchem/workflows/Test%20for%20DeepChem%20Core/badge.svg)](https://github.com/deepchem/deepchem/actions?query=workflow%3A%22Test+for+DeepChem+Core%22)
+[![Test for documents](https://github.com/deepchem/deepchem/workflows/Test%20for%20documents/badge.svg)](https://github.com/deepchem/deepchem/actions?query=workflow%3A%22Test+for+documents%22)
+[![Test for build scripts](https://github.com/deepchem/deepchem/workflows/Test%20for%20build%20scripts/badge.svg)](https://github.com/deepchem/deepchem/actions?query=workflow%3A%22Test+for+build+scripts%22)
+[![codecov](https://codecov.io/gh/deepchem/deepchem/branch/master/graph/badge.svg?token=5rOZB2BY3h)](https://codecov.io/gh/deepchem/deepchem)  
+
+[Website](https://deepchem.io/) | [Documentation](https://deepchem.readthedocs.io/en/latest/) | [Colab Tutorial](https://github.com/deepchem/deepchem/tree/master/examples/tutorials) | [Discussion Forum](https://forum.deepchem.io/) | [Discord](https://discord.gg/cGzwCdrUqS) | [Model Wishlist](https://github.com/deepchem/deepchem/issues/2680) | [Tutorial Wishlist](https://github.com/deepchem/deepchem/issues/2907)
+
+DeepChem aims to provide a high quality open-source toolchain
+that democratizes the use of deep-learning in drug discovery,
+materials science, quantum chemistry, and biology.
+
+### Table of contents:
+
+- [Requirements](#requirements)
+- [Installation](#installation)
+  - [Stable version](#stable-version)
+  - [Nightly build version](#nightly-build-version)
+  - [Docker](#docker)
+  - [From source](#from-source)
+  - [From source lightweight](#from-source-lightweight)
+- [Getting Started](#getting-started)
+  - [Discord](#discord)
+- [About Us](#about-us)
+- [Contributing to DeepChem](/CONTRIBUTING.md)
+- [Citing DeepChem](#citing-deepchem)
+
+## Requirements
+
+DeepChem currently supports Python 3.7 through 3.10 and requires these packages on any condition.
+
+- [joblib](https://pypi.python.org/pypi/joblib)
+- [NumPy](https://numpy.org/)
+- [pandas](http://pandas.pydata.org/)
+- [scikit-learn](https://scikit-learn.org/stable/)
+- [SciPy](https://www.scipy.org/)
+- [rdkit](https://www.rdkit.org/)
+
+### Soft Requirements
+
+DeepChem has a number of "soft" requirements.
+If you face some errors like `ImportError: This class requires XXXX`, you may need to install some packages.
+
+Please check [the document](https://deepchem.readthedocs.io/en/latest/requirements.html#soft-requirements) about soft requirements.
+
+## Installation
+
+### Stable version
+
+DeepChem stable version can be installed using pip or conda as
+
+```bash
+pip install deepchem
+```
+or 
+```
+conda install -c conda-forge deepchem
+```
+
+Deepchem provides support for tensorflow, pytorch, jax and each require
+a individual pip Installation.
+
+For using models with tensorflow dependencies, you install using
+
+```bash
+pip install deepchem[tensorflow]
+```
+For using models with torch dependencies, you install using
+
+```bash
+pip install deepchem[torch]
+```
+For using models with jax dependencies, you install using
+
+```bash
+pip install deepchem[jax]
+```
+If GPU support is required, then make sure CUDA is installed and then install the desired deep learning framework using the links below before installing deepchem
+
+1. tensorflow - just cuda installed
+2. pytorch - https://pytorch.org/get-started/locally/#start-locally
+3. jax - https://github.com/google/jax#pip-installation-gpu-cuda
+
+In `zsh` square brackets are used for globbing/pattern matching. This means you
+need to escape the square brackets in the above installation. You can do so
+by including the dependencies in quotes like `pip install --pre 'deepchem[jax]'`
+
+### Nightly build version
+The nightly version is built by the HEAD of DeepChem. It can be installed using
+
+```bash
+pip install --pre deepchem
+```
+
+### Docker
+
+If you want to install deepchem using a docker, you can pull two kinds of images.  
+DockerHub : https://hub.docker.com/repository/docker/deepchemio/deepchem
+
+- `deepchemio/deepchem:x.x.x`
+  - Image built by using a conda (x.x.x is a version of deepchem)
+  - The x.x.x image is built when we push x.x.x. tag
+  - Dockerfile is put in `docker/tag` directory
+- `deepchemio/deepchem:latest`
+  - Image built from source codes
+  - The latest image is built every time we commit to the master branch
+  - Dockerfile is put in `docker/nightly` directory
+
+You pull the image like this.
+
+```bash
+docker pull deepchemio/deepchem:2.4.0
+```
+
+If you want to know docker usages with deepchem in more detail, please check [the document](https://deepchem.readthedocs.io/en/latest/installation.html#docker).
+
+### From source
+
+If you try install all soft dependencies at once or contribute to deepchem, we recommend you should install deepchem from source.
+
+Please check [this introduction](https://deepchem.readthedocs.io/en/latest/installation.html#from-source-with-conda).
+
+## Getting Started
+
+The DeepChem project maintains an extensive collection of [tutorials](https://github.com/deepchem/deepchem/tree/master/examples/tutorials). All tutorials are designed to be run on Google colab (or locally if you prefer). Tutorials are arranged in a suggested learning sequence which will take you from beginner to proficient at molecular machine learning and computational biology more broadly.
+
+After working through the tutorials, you can also go through other [examples](https://github.com/deepchem/deepchem/tree/master/examples). To apply `deepchem` to a new problem, try starting from one of the existing examples or tutorials and modifying it step by step to work with your new use-case. If you have questions or comments you can raise them on our [gitter](https://gitter.im/deepchem/Lobby).
+
+### Supported Integrations
+
+- [Weights & Biases](https://docs.wandb.ai/guides/integrations/other/deepchem): Track your DeepChem model's training and evaluation metrics.
+
+### Discord
+
+The DeepChem [Discord](https://discord.gg/cGzwCdrUqS) hosts a number of scientists, developers, and enthusiasts interested in deep learning for the life sciences. Probably the easiest place to ask simple questions or float requests for new features.
+
+## About Us
+
+DeepChem is managed by a team of open source contributors. Anyone is free to join and contribute!
+
+## Citing DeepChem
+
+If you have used DeepChem in the course of your research, we ask that you cite the "Deep Learning for the Life Sciences" book by the DeepChem core team.
+
+To cite this book, please use this bibtex entry:
+
+```
+@book{Ramsundar-et-al-2019,
+    title={Deep Learning for the Life Sciences},
+    author={Bharath Ramsundar and Peter Eastman and Patrick Walters and Vijay Pande and Karl Leswing and Zhenqin Wu},
+    publisher={O'Reilly Media},
+    note={\url{https://www.amazon.com/Deep-Learning-Life-Sciences-Microscopy/dp/1492039837}},
+    year={2019}
+}
+```

deepchem/source/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""
+deepchem Project Package Initialization File
+"""

deepchem/source/contrib/DeepMHC/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

deepchem/source/contrib/DeepMHC/bd13_datasets.py

@@ -0,0 +1,150 @@
+"""BD2013 dataset loader to be used with DeepMHC."""
+
+from __future__ import division
+from __future__ import print_function
+
+__author__ = "Vignesh Ram Somnath"
+__license__ = "MIT"
+
+import numpy as np
+import os
+import logging
+
+import deepchem as dc
+
+DATASET_URL = "http://tools.iedb.org/static/main/binding_data_2013.zip"
+FILE_NAME = "bdata.20130222.mhci.txt"
+
+TEST_FILES = [
+    "2016-12-09", "2016-05-03", "2016-02-19", "2015-08-07", "2015-07-31",
+    "2015-07-17", "2015-06-26", "2015-06-19", "2015-05-15", "2015-02-06",
+    "2015-01-16", "2014-10-31", "2014-06-20", "2014-05-23", "2014-03-28",
+    "2014-03-21"
+]
+
+TEST_URLS = [
+    "http://tools.iedb.org/auto_bench/mhci/weekly/accumulated/" + str(date) +
+    "/predictions" for date in TEST_FILES
+]
+
+logger = logging.getLogger(__name__)
+
+aa_charset = [
+    "A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P",
+    "S", "T", "W", "Y", "V"
+]
+
+
+def to_one_hot_array(sequence):
+  """Converts the sequence to one-hot-array."""
+  one_hot_array = list()
+  for letter in sequence:
+    one_hot_array.append([letter == i for i in aa_charset])
+  return np.asarray(one_hot_array, dtype=np.int32)
+
+
+def featurize(sequences, pad_length=13):
+  """One-hot encoding for sequences with padding."""
+  features = list()
+  for sequence in sequences:
+    one_hot_seq = to_one_hot_array(sequence)
+    num_to_pad = pad_length - len(sequence)
+    if num_to_pad % 2 == 0:
+      one_hot_seq = np.pad(
+          one_hot_seq, [(int(num_to_pad / 2), int(num_to_pad / 2)), (0, 0)],
+          mode='constant')
+    else:
+      one_hot_seq = np.pad(
+          one_hot_seq, [(int((num_to_pad + 1) / 2), int((num_to_pad - 1) / 2)),
+                        (0, 0)],
+          mode='constant')
+    features.append(one_hot_seq)
+  features = np.asarray(features)
+  return features
+
+
+def load_bd2013_human(mhc_allele="HLA-A*02:01",
+                      seq_len=9,
+                      pad_len=13,
+                      test_measure_type="ic50",
+                      reload=True):
+  """Loads the human specific data from the bd2013 dataset."""
+  bd13_tasks = ["-log(IC50)"]
+
+  data_dir = dc.utils.get_data_dir()
+  save_dir = os.path.join(data_dir, "bd13", mhc_allele, str(seq_len))
+  train_dir = os.path.join(save_dir, "train_dir")
+  test_dir = os.path.join(save_dir, "test_dir")
+
+  # TODO (VIGS25): Account for the reload option
+
+  # Downloading train files
+  train_file = os.path.join(data_dir, "binding_data_2013.zip")
+  if not os.path.exists(train_file):
+    logger.info("Downloading Binding data...")
+    dc.utils.download_url(url=DATASET_URL, dest_dir=data_dir)
+  if os.path.exists(train_dir):
+    logger.info("Directory for training data already exists")
+  else:
+    logger.info("Unzipping full dataset...")
+    dc.utils.unzip_file(file=train_file, dest_dir=data_dir)
+
+  # Parsing training data
+  train_labels = list()
+  train_sequences = list()
+  with open(os.path.join(data_dir, FILE_NAME), "r") as f:
+    for line in f.readlines():
+      elements = line.strip().split("\t")
+      # Pick only sequences from humans, belong to specific MHC allele and having given seq_len
+      if elements[0] == "human" and elements[1] == mhc_allele and int(
+          elements[2]) == seq_len:
+        train_sequences.append(elements[3])
+        train_labels.append(float(elements[-1]))
+
+  # Test Files loading
+  test_labels = list()
+  test_sequences = list()
+  test_check_file = os.path.join(data_dir, TEST_FILES[0] + '_predictions.tsv')
+  if not os.path.exists(test_check_file):
+    for index, filename in enumerate(TEST_FILES):
+      test_url = TEST_URLS[index]
+      test_filename = filename + '_predictions.tsv'
+      dc.utils.download_url(url=test_url, dest_dir=data_dir, name=test_filename)
+
+  for filename in TEST_FILES:
+    test_filename = os.path.join(data_dir, filename + '_predictions.tsv')
+    with open(test_filename, 'r') as f:
+      for line in f.readlines():
+        elements = line.strip().split("\t")
+        if len(elements) == 1:
+          continue
+        if elements[2] == mhc_allele and int(
+            elements[3]) == seq_len and elements[4] == test_measure_type:
+          test_sequences.append(elements[5])
+          test_labels.append(float(elements[6]))
+
+  # One Hot Featurization
+  logger.info("Featurizing training data...")
+  train_features = featurize(train_sequences, pad_length=pad_len)
+  train_labels = np.array(train_labels).astype(np.float32)
+  train_labels = np.expand_dims(train_labels, axis=1)
+
+  logger.info("Featurizing test data...")
+  test_features = featurize(test_sequences, pad_length=pad_len)
+  test_labels = np.array(test_labels).astype(np.float32)
+  test_labels = np.expand_dims(test_labels, axis=1)
+
+  train_dataset = dc.data.DiskDataset.from_numpy(train_features, train_labels)
+  test_dataset = dc.data.DiskDataset.from_numpy(test_features, test_labels)
+
+  train_dataset.move(new_data_dir=train_dir)
+  test_dataset.move(new_data_dir=test_dir)
+
+  logger.info("Featurization complete.")
+
+  transformers = []
+  for transformer in transformers:
+    train_dataset = transformer.transform(train_dataset)
+    test_dataset = transformer.transform(test_dataset)
+
+  return bd13_tasks, (train_dataset, None, test_dataset), transformers

deepchem/source/contrib/DeepMHC/deepmhc.py

@@ -0,0 +1,107 @@
+"""DeepMHC model, found in https://www.biorxiv.org/content/early/2017/12/24/239236"""
+
+from __future__ import division
+from __future__ import unicode_literals
+
+__author__ = "Vignesh Ram Somnath"
+__license__ = "MIT"
+
+import numpy as np
+import tensorflow as tf
+
+from deepchem.data import NumpyDataset
+from deepchem.models.tensorgraph.tensor_graph import TensorGraph
+from deepchem.models.tensorgraph.layers import Conv1D, MaxPool1D, Dense, Dropout
+from deepchem.models.tensorgraph.layers import Flatten
+from deepchem.models.tensorgraph.layers import Feature, Weights, Label
+from deepchem.models.tensorgraph.layers import L2Loss, WeightedError
+
+
+class DeepMHC(TensorGraph):
+
+  name = ['DeepMHC']
+
+  def __init__(self,
+               batch_size=64,
+               pad_length=13,
+               dropout_p=0.5,
+               num_amino_acids=20,
+               mode="regression",
+               **kwargs):
+
+    assert mode in ["regression", "classification"]
+    self.mode = mode
+    self.batch_size = batch_size
+    self.dropout_p = dropout_p
+    self.pad_length = pad_length
+    self.num_amino_acids = num_amino_acids
+    super(DeepMHC, self).__init__(**kwargs)
+    self._build_graph()
+
+  def _build_graph(self):
+
+    self.one_hot_seq = Feature(
+        shape=(None, self.pad_length, self.num_amino_acids), dtype=tf.float32)
+
+    conv1 = Conv1D(kernel_size=2, filters=512, in_layers=[self.one_hot_seq])
+
+    maxpool1 = MaxPool1D(strides=2, padding="VALID", in_layers=[conv1])
+    conv2 = Conv1D(kernel_size=3, filters=512, in_layers=[maxpool1])
+    flattened = Flatten(in_layers=[conv2])
+    dense1 = Dense(
+        out_channels=400, in_layers=[flattened], activation_fn=tf.nn.tanh)
+    dropout = Dropout(dropout_prob=self.dropout_p, in_layers=[dense1])
+    output = Dense(out_channels=1, in_layers=[dropout], activation_fn=None)
+    self.add_output(output)
+
+    if self.mode == "regression":
+      label = Label(shape=(None, 1))
+      loss = L2Loss(in_layers=[label, output])
+    else:
+      raise NotImplementedError(
+          "Classification support not added yet. Missing details in paper.")
+    weights = Weights(shape=(None,))
+    weighted_loss = WeightedError(in_layers=[loss, weights])
+    self.set_loss(weighted_loss)
+
+  def default_generator(self,
+                        dataset,
+                        epochs=1,
+                        predict=False,
+                        deterministic=True,
+                        pad_batches=True):
+
+    for epoch in range(epochs):
+      for (X_b, y_b, w_b,
+           ids_b) in dataset.iterbatches(batch_size=self.batch_size):
+        feed_dict = {}
+        feed_dict[self.one_hot_seq] = X_b
+        if y_b is not None:
+          feed_dict[self.labels[0]] = -np.log10(y_b)
+        if w_b is not None and not predict:
+          feed_dict[self.task_weights[0]] = w_b
+
+        yield feed_dict
+
+  def predict_on_batch(self, X, transformers=[], outputs=None):
+    dataset = NumpyDataset(X, y=None)
+    generator = self.default_generator(dataset, predict=True, pad_batches=False)
+    preds = self.predict_on_generator(generator, transformers, outputs)
+    preds = 10**-preds  # Since we get train on -log10(IC50)
+    return preds
+
+  def create_estimator_inputs(self, feature_columns, weight_column, features,
+                              labels, mode):
+    tensors = dict()
+    for layer, column in zip(self.features, feature_columns):
+      feature_column = tf.feature_column.input_layer(features, [column])
+      if feature_column.dtype != column.dtype:
+        feature_column = tf.cast(feature_column, column.dtype)
+      tensors[layer] = feature_column
+    if weight_column is not None:
+      tensors[self.task_weights[0]] = tf.feature_column.input_layer(
+          features, [weight_column])
+    if labels is not None:
+      tensors[self.labels[[0]]] = labels
+
+    return tensors

deepchem/source/contrib/DeepMHC/run_deepmhc.py

@@ -0,0 +1,41 @@
+"""
+Script to train DeepMHC model on the BD2013 dataset.
+"""
+
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+from bd13_datasets import aa_charset, load_bd2013_human
+from deepmhc import DeepMHC
+
+import numpy as np
+import deepchem as dc
+from scipy.stats import spearmanr
+
+# Args
+pad_len = 13
+num_amino_acids = len(aa_charset)
+mhc_allele = "HLA-A*02:01"
+dropout_p = 0.5
+batch_size = 64
+nb_epochs = 100
+
+tasks, datasets, transformers = load_bd2013_human(
+    mhc_allele=mhc_allele, seq_len=9, pad_len=pad_len)
+metric = dc.metrics.Metric(metric=dc.metrics.pearsonr, mode="regression")
+
+train_dataset, _, test_dataset = datasets
+model = DeepMHC(num_amino_acids=num_amino_acids, pad_length=pad_len)
+
+model.fit(train_dataset, nb_epoch=nb_epochs)
+
+print("Evaluating models...")
+train_scores = model.evaluate(train_dataset, [metric], transformers)
+test_scores = model.evaluate(test_dataset, [metric], transformers)
+
+print("Train scores")
+print(train_scores['pearsonr'])
+
+print("Test scores")
+print(test_scores['pearsonr'])

deepchem/source/contrib/DiabeticRetinopathy/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

deepchem/source/contrib/DiabeticRetinopathy/data.py

@@ -0,0 +1,107 @@
+"""
+Diabetic Retinopathy Images loader.
+"""
+from __future__ import division
+from __future__ import unicode_literals
+
+import os
+import logging
+import deepchem
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+def load_images_DR(split='random', seed=None):
+  """ Loader for DR images """
+  data_dir = deepchem.utils.get_data_dir()
+  images_path = os.path.join(data_dir, 'DR', 'train')
+  label_path = os.path.join(data_dir, 'DR', 'trainLabels.csv')
+  if not os.path.exists(images_path) or not os.path.exists(label_path):
+    logger.warn("Cannot locate data, \n\
+        all images(.png) should be stored in the folder: $DEEPCHEM_DATA_DIR/DR/train/,\n\
+        corresponding label file should be stored as $DEEPCHEM_DATA_DIR/DR/trainLabels.csv.\n\
+        Please refer to https://www.kaggle.com/c/diabetic-retinopathy-detection for data access"
+               )
+
+  image_names = os.listdir(images_path)
+  raw_images = []
+  for im in image_names:
+    if im.endswith('.jpeg') and not im.startswith(
+        'cut_') and not 'cut_' + im in image_names:
+      raw_images.append(im)
+  if len(raw_images) > 0:
+    cut_raw_images(raw_images, images_path)
+
+  image_names = [
+      p for p in os.listdir(images_path)
+      if p.startswith('cut_') and p.endswith('.png')
+  ]
+  all_labels = dict(zip(*np.transpose(np.array(pd.read_csv(label_path)))))
+
+  print("Number of images: %d" % len(image_names))
+  labels = np.array(
+      [all_labels[os.path.splitext(n)[0][4:]] for n in image_names]).reshape(
+          (-1, 1))
+  image_full_paths = [os.path.join(images_path, n) for n in image_names]
+
+  classes, cts = np.unique(list(all_labels.values()), return_counts=True)
+  weight_ratio = dict(zip(classes, np.max(cts) / cts.astype(float)))
+  weights = np.array([weight_ratio[l[0]] for l in labels]).reshape((-1, 1))
+
+  loader = deepchem.data.ImageLoader()
+  dat = loader.featurize(
+      image_full_paths, labels=labels, weights=weights)
+  if split == None:
+    return dat
+
+  splitters = {
+      'index': deepchem.splits.IndexSplitter(),
+      'random': deepchem.splits.RandomSplitter()
+  }
+  if not seed is None:
+    np.random.seed(seed)
+  splitter = splitters[split]
+  train, valid, test = splitter.train_valid_test_split(dat)
+  all_dataset = (train, valid, test)
+  return all_dataset
+
+
+def cut_raw_images(all_images, path):
+  """Preprocess images:
+    (1) Crop the central square including retina
+    (2) Reduce resolution to 512 * 512
+  """
+  print("Num of images to be processed: %d" % len(all_images))
+  try:
+    import cv2
+  except:
+    logger.warn("OpenCV required for image preprocessing")
+    return
+
+  for i, img_path in enumerate(all_images):
+    if i % 100 == 0:
+      print("on image %d" % i)
+    if os.path.join(path, 'cut_' + os.path.splitext(img_path)[0] + '.png'):
+      continue
+    img = cv2.imread(os.path.join(path, img_path))
+    edges = cv2.Canny(img, 10, 30)
+    coords = zip(*np.where(edges > 0))
+    n_p = len(coords)
+
+    coords.sort(key=lambda x: (x[0], x[1]))
+    center_0 = int(
+        (coords[int(0.01 * n_p)][0] + coords[int(0.99 * n_p)][0]) / 2)
+    coords.sort(key=lambda x: (x[1], x[0]))
+    center_1 = int(
+        (coords[int(0.01 * n_p)][1] + coords[int(0.99 * n_p)][1]) / 2)
+
+    edge_size = min(
+        [center_0, img.shape[0] - center_0, center_1, img.shape[1] - center_1])
+    img_cut = img[(center_0 - edge_size):(center_0 + edge_size), (
+        center_1 - edge_size):(center_1 + edge_size)]
+    img_cut = cv2.resize(img_cut, (512, 512))
+    cv2.imwrite(
+        os.path.join(path, 'cut_' + os.path.splitext(img_path)[0] + '.png'),
+        img_cut)

deepchem/source/contrib/DiabeticRetinopathy/model.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Sep 10 06:12:10 2018
+
+@author: zqwu
+"""
+
+import numpy as np
+import tensorflow as tf
+
+from deepchem.data import NumpyDataset, pad_features
+from deepchem.metrics import to_one_hot
+from deepchem.models.tensorgraph.layers import Layer, Dense, SoftMax, Reshape, \
+    SparseSoftMaxCrossEntropy, BatchNorm, Conv2D, MaxPool2D, WeightedError, \
+    Dropout, ReLU, Stack, Flatten, ReduceMax, WeightDecay
+from deepchem.models.tensorgraph.layers import L2Loss, Label, Weights, Feature
+from deepchem.models.tensorgraph.tensor_graph import TensorGraph
+from deepchem.trans import undo_transforms
+from deepchem.data.data_loader import ImageLoader
+from sklearn.metrics import confusion_matrix, accuracy_score
+
+
+class DRModel(TensorGraph):
+
+  def __init__(self,
+               n_tasks=1,
+               image_size=512,
+               n_downsample=6,
+               n_init_kernel=16,
+               n_fully_connected=[1024],
+               n_classes=5,
+               augment=False,
+               **kwargs):
+    """
+    Parameters
+    ----------
+    n_tasks: int
+      Number of tasks
+    image_size: int
+      Resolution of the input images(square)
+    n_downsample: int
+      Downsample ratio in power of 2
+    n_init_kernel: int
+      Kernel size for the first convolutional layer
+    n_fully_connected: list of int
+      Shape of FC layers after convolutions
+    n_classes: int
+      Number of classes to predict (only used in classification mode)
+    augment: bool
+      If to use data augmentation
+    """
+    self.n_tasks = n_tasks
+    self.image_size = image_size
+    self.n_downsample = n_downsample
+    self.n_init_kernel = n_init_kernel
+    self.n_fully_connected = n_fully_connected
+    self.n_classes = n_classes
+    self.augment = augment
+    super(DRModel, self).__init__(**kwargs)
+    self.build_graph()
+
+  def build_graph(self):
+    # inputs placeholder
+    self.inputs = Feature(
+        shape=(None, self.image_size, self.image_size, 3), dtype=tf.float32)
+    # data preprocessing and augmentation
+    in_layer = DRAugment(
+        self.augment,
+        self.batch_size,
+        size=(self.image_size, self.image_size),
+        in_layers=[self.inputs])
+    # first conv layer
+    in_layer = Conv2D(
+        self.n_init_kernel,
+        kernel_size=7,
+        activation_fn=None,
+        in_layers=[in_layer])
+    in_layer = BatchNorm(in_layers=[in_layer])
+    in_layer = ReLU(in_layers=[in_layer])
+
+    # downsample by max pooling
+    res_in = MaxPool2D(
+        ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], in_layers=[in_layer])
+
+    for ct_module in range(self.n_downsample - 1):
+      # each module is a residual convolutional block
+      # followed by a convolutional downsample layer
+      in_layer = Conv2D(
+          self.n_init_kernel * 2**(ct_module - 1),
+          kernel_size=1,
+          activation_fn=None,
+          in_layers=[res_in])
+      in_layer = BatchNorm(in_layers=[in_layer])
+      in_layer = ReLU(in_layers=[in_layer])
+      in_layer = Conv2D(
+          self.n_init_kernel * 2**(ct_module - 1),
+          kernel_size=3,
+          activation_fn=None,
+          in_layers=[in_layer])
+      in_layer = BatchNorm(in_layers=[in_layer])
+      in_layer = ReLU(in_layers=[in_layer])
+      in_layer = Conv2D(
+          self.n_init_kernel * 2**ct_module,
+          kernel_size=1,
+          activation_fn=None,
+          in_layers=[in_layer])
+      res_a = BatchNorm(in_layers=[in_layer])
+
+      res_out = res_in + res_a
+      res_in = Conv2D(
+          self.n_init_kernel * 2**(ct_module + 1),
+          kernel_size=3,
+          stride=2,
+          in_layers=[res_out])
+      res_in = BatchNorm(in_layers=[res_in])
+
+    # max pooling over the final outcome
+    in_layer = ReduceMax(axis=(1, 2), in_layers=[res_in])
+
+    for layer_size in self.n_fully_connected:
+      # fully connected layers
+      in_layer = Dense(
+          layer_size, activation_fn=tf.nn.relu, in_layers=[in_layer])
+      # dropout for dense layers
+      #in_layer = Dropout(0.25, in_layers=[in_layer])
+
+    logit_pred = Dense(
+        self.n_tasks * self.n_classes, activation_fn=None, in_layers=[in_layer])
+    logit_pred = Reshape(
+        shape=(None, self.n_tasks, self.n_classes), in_layers=[logit_pred])
+
+    weights = Weights(shape=(None, self.n_tasks))
+    labels = Label(shape=(None, self.n_tasks), dtype=tf.int32)
+
+    output = SoftMax(logit_pred)
+    self.add_output(output)
+    loss = SparseSoftMaxCrossEntropy(in_layers=[labels, logit_pred])
+    weighted_loss = WeightedError(in_layers=[loss, weights])
+
+    # weight decay regularizer
+    # weighted_loss = WeightDecay(0.1, 'l2', in_layers=[weighted_loss])
+    self.set_loss(weighted_loss)
+
+
+def DRAccuracy(y, y_pred):
+  y_pred = np.argmax(y_pred, 1)
+  return accuracy_score(y, y_pred)
+
+
+def DRSpecificity(y, y_pred):
+  y_pred = (np.argmax(y_pred, 1) > 0) * 1
+  y = (y > 0) * 1
+  TN = sum((1 - y_pred) * (1 - y))
+  N = sum(1 - y)
+  return float(TN) / N
+
+
+def DRSensitivity(y, y_pred):
+  y_pred = (np.argmax(y_pred, 1) > 0) * 1
+  y = (y > 0) * 1
+  TP = sum(y_pred * y)
+  P = sum(y)
+  return float(TP) / P
+
+
+def ConfusionMatrix(y, y_pred):
+  y_pred = np.argmax(y_pred, 1)
+  return confusion_matrix(y, y_pred)
+
+
+def QuadWeightedKappa(y, y_pred):
+  y_pred = np.argmax(y_pred, 1)
+  cm = confusion_matrix(y, y_pred)
+  classes_y, counts_y = np.unique(y, return_counts=True)
+  classes_y_pred, counts_y_pred = np.unique(y_pred, return_counts=True)
+  E = np.zeros((classes_y.shape[0], classes_y.shape[0]))
+  for i, c1 in enumerate(classes_y):
+    for j, c2 in enumerate(classes_y_pred):
+      E[c1, c2] = counts_y[i] * counts_y_pred[j]
+  E = E / np.sum(E) * np.sum(cm)
+  w = np.zeros((classes_y.shape[0], classes_y.shape[0]))
+  for i in range(classes_y.shape[0]):
+    for j in range(classes_y.shape[0]):
+      w[i, j] = float((i - j)**2) / (classes_y.shape[0] - 1)**2
+  re = 1 - np.sum(w * cm) / np.sum(w * E)
+  return re
+
+
+class DRAugment(Layer):
+
+  def __init__(self,
+               augment,
+               batch_size,
+               distort_color=True,
+               central_crop=True,
+               size=(512, 512),
+               **kwargs):
+    """
+    Parameters
+    ----------
+    augment: bool
+      If to use data augmentation
+    batch_size: int
+      Number of images in the batch
+    distort_color: bool
+      If to apply random distortion on the color
+    central_crop: bool
+      If to randomly crop the sample around the center
+    size: int
+      Resolution of the input images(square)
+    """
+    self.augment = augment
+    self.batch_size = batch_size
+    self.distort_color = distort_color
+    self.central_crop = central_crop
+    self.size = size
+    super(DRAugment, self).__init__(**kwargs)
+
+  def create_tensor(self, in_layers=None, set_tensors=True, **kwargs):
+    inputs = self._get_input_tensors(in_layers)
+    parent_tensor = inputs[0]
+    training = kwargs['training'] if 'training' in kwargs else 1.0
+
+    parent_tensor = parent_tensor / 255.0
+    if not self.augment:
+      out_tensor = parent_tensor
+    else:
+
+      def preprocess(img):
+        img = tf.image.random_flip_left_right(img)
+        img = tf.image.random_flip_up_down(img)
+        img = tf.image.rot90(img, k=np.random.randint(0, 4))
+        if self.distort_color:
+          img = tf.image.random_brightness(img, max_delta=32. / 255.)
+          img = tf.image.random_saturation(img, lower=0.5, upper=1.5)
+          img = tf.clip_by_value(img, 0.0, 1.0)
+        if self.central_crop:
+          # sample cut ratio from a clipped gaussian
+          img = tf.image.central_crop(img,
+                                      np.clip(
+                                          np.random.normal(1., 0.06), 0.8, 1.))
+          img = tf.image.resize_bilinear(
+              tf.expand_dims(img, 0), tf.convert_to_tensor(self.size))[0]
+        return img
+
+      outs = tf.map_fn(preprocess, parent_tensor)
+      # train/valid differences
+      out_tensor = training * outs + (1 - training) * parent_tensor
+    if set_tensors:
+      self.out_tensor = out_tensor
+    return out_tensor

deepchem/source/contrib/DiabeticRetinopathy/run.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Sep 10 06:12:11 2018
+
+@author: zqwu
+"""
+
+import deepchem as dc
+import numpy as np
+import pandas as pd
+import os
+import logging
+from model import DRModel, DRAccuracy, ConfusionMatrix, QuadWeightedKappa
+from data import load_images_DR
+
+train, valid, test = load_images_DR(split='random', seed=123)
+# Define and build model
+model = DRModel(
+    n_init_kernel=32,
+    batch_size=32,
+    learning_rate=1e-5,
+    augment=True,
+    model_dir='./test_model')
+if not os.path.exists('./test_model'):
+  os.mkdir('test_model')
+model.build()
+#model.restore()
+metrics = [
+    dc.metrics.Metric(DRAccuracy, mode='classification'),
+    dc.metrics.Metric(QuadWeightedKappa, mode='classification')
+]
+cm = [dc.metrics.Metric(ConfusionMatrix, mode='classification')]
+
+logger = logging.getLogger('deepchem.models.tensorgraph.tensor_graph')
+logger.setLevel(logging.DEBUG)
+for i in range(10):
+  model.fit(train, nb_epoch=10, checkpoint_interval=3512)
+  model.evaluate(train, metrics)
+  model.evaluate(valid, metrics)
+  model.evaluate(valid, cm)
+  model.evaluate(test, metrics)
+  model.evaluate(test, cm)

deepchem/source/contrib/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

deepchem/source/contrib/atomicconv/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

deepchem/source/contrib/atomicconv/acnn/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

deepchem/source/contrib/atomicconv/acnn/core/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

deepchem/source/contrib/atomicconv/acnn/core/get_acnn_core.sh

@@ -0,0 +1,4 @@
+echo "Pulling featurized and split ACNN datasets from deepchem"
+wget http://deepchem.io.s3-website-us-west-1.amazonaws.com/featurized_datasets/acnn_core.tar.gz
+echo "Extracting ACNN datasets"
+tar -zxvf acnn_core.tar.gz

deepchem/source/contrib/atomicconv/acnn/core/opt_random.py

@@ -0,0 +1,119 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+__author__ = "Joseph Gomes"
+__copyright__ = "Copyright 2017, Stanford University"
+__license__ = "MIT"
+
+import os
+import sys
+import deepchem as dc
+import numpy as np
+import tensorflow as tf
+
+sys.path.append("../../models")
+from atomicnet_ops import create_symmetry_parameters
+from atomicnet import TensorflowFragmentRegressor
+
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "random_train")
+test_dir = os.path.join(data_dir, "random_test")
+model_dir = os.path.join(base_dir, "random_model")
+
+frag1_num_atoms = 70
+frag2_num_atoms = 634
+complex_num_atoms = 701
+max_num_neighbors = 12
+neighbor_cutoff = 12.0
+
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+pdbbind_tasks = ["-logKd/Ki"]
+transformers = []
+#transformers = [dc.trans.NormalizationTransformer(transform_y=True, dataset=train_dataset)]
+#for transformer in transformers:
+#  train_dataset = transformer.transform(train_dataset)
+#  test_dataset = transformer.transform(test_dataset)
+
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+at = [6, 7., 8., 9., 11., 12., 15., 16., 17., 20., 25., 30., 35., 53.]
+radial = [[
+    1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5,
+    9.0, 9.5, 10.0, 10.5, 11.0, 11.5, 12.0
+], [0.0, 4.0, 8.0], [0.4]]
+#radial = [[12.0], [0.0, 4.0, 8.0], [0.4]]
+rp = create_symmetry_parameters(radial)
+layer_sizes = [32, 32, 16]
+weight_init_stddevs = [
+    1 / np.sqrt(layer_sizes[0]), 1 / np.sqrt(layer_sizes[1]),
+    1 / np.sqrt(layer_sizes[2])
+]
+dropouts = [0.3, 0.3, 0.05]
+penalty_type = "l2"
+penalty = 0.
+model = TensorflowFragmentRegressor(
+    len(pdbbind_tasks),
+    rp,
+    at,
+    frag1_num_atoms,
+    frag2_num_atoms,
+    complex_num_atoms,
+    max_num_neighbors,
+    logdir=model_dir,
+    layer_sizes=layer_sizes,
+    weight_init_stddevs=weight_init_stddevs,
+    bias_init_consts=[0., 0., 0.],
+    penalty=penalty,
+    penalty_type=penalty_type,
+    dropouts=dropouts,
+    learning_rate=0.002,
+    momentum=0.8,
+    optimizer="adam",
+    batch_size=24,
+    conv_layers=1,
+    boxsize=None,
+    verbose=True,
+    seed=seed)
+model.fit(train_dataset, nb_epoch=10)
+metric = [
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression"),
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression")
+]
+train_evaluator = dc.utils.evaluate.Evaluator(model, train_dataset,
+                                              transformers)
+train_scores = train_evaluator.compute_model_performance(
+    metric,
+    csv_out="train_predict_ac_random.csv",
+    stats_out="train_stats_ac_random.csv")
+print("Train scores")
+print(train_scores)
+test_evaluator = dc.utils.evaluate.Evaluator(model, test_dataset, transformers)
+test_scores = test_evaluator.compute_model_performance(
+    metric,
+    csv_out="test_predict_ac_random.csv",
+    stats_out="test_stats_ac_random.csv")
+print("Test scores")
+print(test_scores)

deepchem/source/contrib/atomicconv/acnn/core/opt_random_tensorgraph.py

@@ -0,0 +1,73 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+import os
+import sys
+import deepchem as dc
+import numpy as np
+import tensorflow as tf
+from deepchem.models.atomic_conv import atomic_conv_model
+
+sys.path.append("../../models")
+from deepchem.models.tensorgraph.layers import Layer, Feature, Label, L2Loss, AtomicConvolution, Transpose, Dense
+from deepchem.models import TensorGraph
+
+import numpy as np
+import tensorflow as tf
+import itertools
+import time
+
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "random_train")
+test_dir = os.path.join(data_dir, "random_test")
+model_dir = os.path.join(base_dir, "random_model")
+
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+pdbbind_tasks = ["-logKd/Ki"]
+transformers = []
+
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+batch_size = 24
+tg, feed_dict_generator, label = atomic_conv_model()
+
+print("Fitting")
+metric = [
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression"),
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression")
+]
+tg.fit_generator(feed_dict_generator(train_dataset, batch_size, epochs=10))
+
+train_evaluator = dc.utils.evaluate.GeneratorEvaluator(
+    tg, feed_dict_generator(train_dataset, batch_size), transformers, [label])
+train_scores = train_evaluator.compute_model_performance(metric)
+print("Train scores")
+print(train_scores)
+test_evaluator = dc.utils.evaluate.GeneratorEvaluator(
+    tg, feed_dict_generator(test_dataset, batch_size), transformers, [label])
+test_scores = test_evaluator.compute_model_performance(metric)
+print("Test scores")
+print(test_scores)

deepchem/source/contrib/atomicconv/acnn/core/opt_scaffold.py

@@ -0,0 +1,119 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+__author__ = "Joseph Gomes"
+__copyright__ = "Copyright 2017, Stanford University"
+__license__ = "MIT"
+
+import os
+import sys
+import deepchem as dc
+import numpy as np
+import tensorflow as tf
+
+sys.path.append("../../models")
+from atomicnet_ops import create_symmetry_parameters
+from atomicnet import TensorflowFragmentRegressor
+
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "scaffold_train")
+test_dir = os.path.join(data_dir, "scaffold_test")
+model_dir = os.path.join(base_dir, "scaffold_model")
+
+frag1_num_atoms = 70
+frag2_num_atoms = 634
+complex_num_atoms = 701
+max_num_neighbors = 12
+neighbor_cutoff = 12.0
+
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+pdbbind_tasks = ["-logKd/Ki"]
+transformers = []
+#transformers = [dc.trans.NormalizationTransformer(transform_y=True, dataset=train_dataset)]
+#for transformer in transformers:
+#  train_dataset = transformer.transform(train_dataset)
+#  test_dataset = transformer.transform(test_dataset)
+
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+at = [6, 7., 8., 9., 11., 12., 15., 16., 17., 20., 25., 30., 35., 53.]
+radial = [[
+    1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5,
+    9.0, 9.5, 10.0, 10.5, 11.0, 11.5, 12.0
+], [0.0, 4.0, 8.0], [0.4]]
+#radial = [[12.0], [0.0, 4.0, 8.0], [0.4]]
+rp = create_symmetry_parameters(radial)
+layer_sizes = [32, 32, 16]
+weight_init_stddevs = [
+    1 / np.sqrt(layer_sizes[0]), 1 / np.sqrt(layer_sizes[1]),
+    1 / np.sqrt(layer_sizes[2])
+]
+dropouts = [0.3, 0.3, 0.05]
+penalty_type = "l2"
+penalty = 0.
+model = TensorflowFragmentRegressor(
+    len(pdbbind_tasks),
+    rp,
+    at,
+    frag1_num_atoms,
+    frag2_num_atoms,
+    complex_num_atoms,
+    max_num_neighbors,
+    logdir=model_dir,
+    layer_sizes=layer_sizes,
+    weight_init_stddevs=weight_init_stddevs,
+    bias_init_consts=[0., 0., 0.],
+    penalty=penalty,
+    penalty_type=penalty_type,
+    dropouts=dropouts,
+    learning_rate=0.002,
+    momentum=0.8,
+    optimizer="adam",
+    batch_size=64,
+    conv_layers=1,
+    boxsize=None,
+    verbose=True,
+    seed=seed)
+model.fit(train_dataset, nb_epoch=100)
+metric = [
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression"),
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression")
+]
+train_evaluator = dc.utils.evaluate.Evaluator(model, train_dataset,
+                                              transformers)
+train_scores = train_evaluator.compute_model_performance(
+    metric,
+    csv_out="train_predict_ac_scaffold.csv",
+    stats_out="train_stats_ac_scaffold.csv")
+print("Train scores")
+print(train_scores)
+test_evaluator = dc.utils.evaluate.Evaluator(model, test_dataset, transformers)
+test_scores = test_evaluator.compute_model_performance(
+    metric,
+    csv_out="test_predict_ac_scaffold.csv",
+    stats_out="test_stats_ac_scaffold.csv")
+print("Test scores")
+print(test_scores)

deepchem/source/contrib/atomicconv/acnn/core/opt_stratified.py

@@ -0,0 +1,119 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+__author__ = "Joseph Gomes"
+__copyright__ = "Copyright 2017, Stanford University"
+__license__ = "MIT"
+
+import os
+import sys
+import deepchem as dc
+import numpy as np
+import tensorflow as tf
+
+sys.path.append("../../models")
+from atomicnet_ops import create_symmetry_parameters
+from atomicnet import TensorflowFragmentRegressor
+
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "stratified_train")
+test_dir = os.path.join(data_dir, "stratified_test")
+model_dir = os.path.join(base_dir, "stratified_model")
+
+frag1_num_atoms = 70
+frag2_num_atoms = 634
+complex_num_atoms = 701
+max_num_neighbors = 12
+neighbor_cutoff = 12.0
+
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+pdbbind_tasks = ["-logKd/Ki"]
+transformers = []
+#transformers = [dc.trans.NormalizationTransformer(transform_y=True, dataset=train_dataset)]
+#for transformer in transformers:
+#  train_dataset = transformer.transform(train_dataset)
+#  test_dataset = transformer.transform(test_dataset)
+
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+at = [6, 7., 8., 9., 11., 12., 15., 16., 17., 20., 25., 30., 35., 53.]
+radial = [[
+    1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5,
+    9.0, 9.5, 10.0, 10.5, 11.0, 11.5, 12.0
+], [0.0, 4.0, 8.0], [0.4]]
+#radial = [[12.0], [0.0, 4.0, 8.0], [0.4]]
+rp = create_symmetry_parameters(radial)
+layer_sizes = [32, 32, 16]
+weight_init_stddevs = [
+    1 / np.sqrt(layer_sizes[0]), 1 / np.sqrt(layer_sizes[1]),
+    1 / np.sqrt(layer_sizes[2])
+]
+dropouts = [0.3, 0.3, 0.05]
+penalty_type = "l2"
+penalty = 0.
+model = TensorflowFragmentRegressor(
+    len(pdbbind_tasks),
+    rp,
+    at,
+    frag1_num_atoms,
+    frag2_num_atoms,
+    complex_num_atoms,
+    max_num_neighbors,
+    logdir=model_dir,
+    layer_sizes=layer_sizes,
+    weight_init_stddevs=weight_init_stddevs,
+    bias_init_consts=[0., 0., 0.],
+    penalty=penalty,
+    penalty_type=penalty_type,
+    dropouts=dropouts,
+    learning_rate=0.002,
+    momentum=0.8,
+    optimizer="adam",
+    batch_size=64,
+    conv_layers=1,
+    boxsize=None,
+    verbose=True,
+    seed=seed)
+model.fit(train_dataset, nb_epoch=100)
+metric = [
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression"),
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression")
+]
+train_evaluator = dc.utils.evaluate.Evaluator(model, train_dataset,
+                                              transformers)
+train_scores = train_evaluator.compute_model_performance(
+    metric,
+    csv_out="train_predict_ac_stratified.csv",
+    stats_out="train_stats_ac_stratified.csv")
+print("Train scores")
+print(train_scores)
+test_evaluator = dc.utils.evaluate.Evaluator(model, test_dataset, transformers)
+test_scores = test_evaluator.compute_model_performance(
+    metric,
+    csv_out="test_predict_ac_stratified.csv",
+    stats_out="test_stats_ac_stratified.csv")
+print("Test scores")
+print(test_scores)

deepchem/source/contrib/atomicconv/acnn/core/opt_temporal.py

@@ -0,0 +1,119 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+__author__ = "Joseph Gomes"
+__copyright__ = "Copyright 2017, Stanford University"
+__license__ = "MIT"
+
+import os
+import sys
+import deepchem as dc
+import numpy as np
+import tensorflow as tf
+
+sys.path.append("../../models")
+from atomicnet_ops import create_symmetry_parameters
+from atomicnet import TensorflowFragmentRegressor
+
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "temporal_train")
+test_dir = os.path.join(data_dir, "temporal_test")
+model_dir = os.path.join(base_dir, "temporal_model")
+
+frag1_num_atoms = 70
+frag2_num_atoms = 634
+complex_num_atoms = 701
+max_num_neighbors = 12
+neighbor_cutoff = 12.0
+
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+pdbbind_tasks = ["-logKd/Ki"]
+transformers = []
+#transformers = [dc.trans.NormalizationTransformer(transform_y=True, dataset=train_dataset)]
+#for transformer in transformers:
+#  train_dataset = transformer.transform(train_dataset)
+#  test_dataset = transformer.transform(test_dataset)
+
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+at = [6, 7., 8., 9., 11., 12., 15., 16., 17., 20., 25., 30., 35., 53.]
+radial = [[
+    1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5,
+    9.0, 9.5, 10.0, 10.5, 11.0, 11.5, 12.0
+], [0.0, 4.0, 8.0], [0.4]]
+#radial = [[12.0], [0.0, 4.0, 8.0], [0.4]]
+rp = create_symmetry_parameters(radial)
+layer_sizes = [32, 32, 16]
+weight_init_stddevs = [
+    1 / np.sqrt(layer_sizes[0]), 1 / np.sqrt(layer_sizes[1]),
+    1 / np.sqrt(layer_sizes[2])
+]
+dropouts = [0.3, 0.3, 0.05]
+penalty_type = "l2"
+penalty = 0.
+model = TensorflowFragmentRegressor(
+    len(pdbbind_tasks),
+    rp,
+    at,
+    frag1_num_atoms,
+    frag2_num_atoms,
+    complex_num_atoms,
+    max_num_neighbors,
+    logdir=model_dir,
+    layer_sizes=layer_sizes,
+    weight_init_stddevs=weight_init_stddevs,
+    bias_init_consts=[0., 0., 0.],
+    penalty=penalty,
+    penalty_type=penalty_type,
+    dropouts=dropouts,
+    learning_rate=0.002,
+    momentum=0.8,
+    optimizer="adam",
+    batch_size=64,
+    conv_layers=1,
+    boxsize=None,
+    verbose=True,
+    seed=seed)
+model.fit(train_dataset, nb_epoch=100)
+metric = [
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression"),
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression")
+]
+train_evaluator = dc.utils.evaluate.Evaluator(model, train_dataset,
+                                              transformers)
+train_scores = train_evaluator.compute_model_performance(
+    metric,
+    csv_out="train_predict_ac_temporal.csv",
+    stats_out="train_stats_ac_temporal.csv")
+print("Train scores")
+print(train_scores)
+test_evaluator = dc.utils.evaluate.Evaluator(model, test_dataset, transformers)
+test_scores = test_evaluator.compute_model_performance(
+    metric,
+    csv_out="test_predict_ac_temporal.csv",
+    stats_out="test_stats_ac_temporal.csv")
+print("Test scores")
+print(test_scores)

deepchem/source/contrib/atomicconv/acnn/core/tensor_graph_hyper_param_eval.py

@@ -0,0 +1,116 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+import os
+import sys
+import deepchem as dc
+import json
+import numpy as np
+import tensorflow as tf
+from deepchem.models.atomic_conv import atomic_conv_model
+
+sys.path.append("../../models")
+from deepchem.models.tensorgraph.layers import Layer, Feature, Label, L2Loss, AtomicConvolution, Transpose, Dense
+from deepchem.models import TensorGraph
+
+import numpy as np
+import tensorflow as tf
+import itertools
+import time
+
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+base_dir = os.getcwd()
+
+batch_size = 24
+splits = ["random", "scaffold", "stratified", "temporal"]
+
+
+def params():
+  d2 = {
+      "name":
+      "hyper5",
+      "radial": [[
+          1.5, 2.5, 3.5, 4.5, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5, 10.0,
+          10.5
+      ], [0.0, 2.0, 4.0], [0.05]],
+      "layer_sizes": [32, 16, 8],
+      "learning_rate":
+      0.001,
+      "epochs":
+      10,
+  }
+  yield d2
+  d2 = {
+      "name":
+      "hyper6",
+      "radial": [[
+          1.5, 2.0, 2.5, 3.5, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0,
+          9.5, 10.0, 10.5
+      ], [0.0, 2.0, 4.0], [0.1]],
+      "layer_sizes": [32, 32, 16],
+      "learning_rate":
+      0.001,
+      "epochs":
+      10,
+  }
+  yield d2
+
+
+metric = [
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression"),
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression")
+]
+for split in splits:
+  data_dir = os.path.join(base_dir, "datasets")
+  train_dir = os.path.join(data_dir, "%s_train" % split)
+  test_dir = os.path.join(data_dir, "%s_test" % split)
+
+  train_dataset = dc.data.DiskDataset(train_dir)
+  test_dataset = dc.data.DiskDataset(test_dir)
+  pdbbind_tasks = ["-logKd/Ki"]
+  transformers = []
+
+  y_train = train_dataset.y
+  y_train *= -1 * 2.479 / 4.184
+  train_dataset = dc.data.DiskDataset.from_numpy(
+      train_dataset.X,
+      y_train,
+      train_dataset.w,
+      train_dataset.ids,
+      tasks=pdbbind_tasks)
+
+  y_test = test_dataset.y
+  y_test *= -1 * 2.479 / 4.184
+  test_dataset = dc.data.DiskDataset.from_numpy(
+      test_dataset.X,
+      y_test,
+      test_dataset.w,
+      test_dataset.ids,
+      tasks=pdbbind_tasks)
+  for param in params():
+    num_epochs = param['epochs']
+    del param['epochs']
+    name = param['name']
+    del param['name']
+
+    tg, feed_dict_generator, label = atomic_conv_model(**param)
+    tg.fit_generator(
+        feed_dict_generator(train_dataset, batch_size, epochs=num_epochs))
+
+    test_evaluator = dc.utils.evaluate.GeneratorEvaluator(
+        tg, feed_dict_generator(test_dataset, batch_size), transformers,
+        [label])
+    test_scores = test_evaluator.compute_model_performance(metric)
+    param.update(test_scores)
+    param['epochs'] = num_epochs
+    param['split'] = split
+    param['name'] = name
+    print("Results")
+    print(param)
+    with open('hyper_evaluation.txt', 'a') as fout:
+      fout.write(json.dumps(param))
+      fout.write("\n")

deepchem/source/contrib/atomicconv/acnn/core/tensor_graph_hyper_param_search.py

@@ -0,0 +1,117 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+import os
+import sys
+import deepchem as dc
+import json
+import numpy as np
+import tensorflow as tf
+from deepchem.models.atomic_conv import atomic_conv_model
+
+sys.path.append("../../models")
+from deepchem.models.tensorgraph.layers import Layer, Feature, Label, L2Loss, AtomicConvolution, Transpose, Dense
+from deepchem.models import TensorGraph
+
+import numpy as np
+import tensorflow as tf
+import itertools
+import time
+
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "scaffold_train")
+test_dir = os.path.join(data_dir, "scaffold_test")
+
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+pdbbind_tasks = ["-logKd/Ki"]
+transformers = []
+
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+batch_size = 24
+radial1 = [
+    [1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5],
+    [
+        1.5, 2.5, 3.5, 4.5, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5, 10.0,
+        10.5
+    ],
+]
+radial2 = [
+    [0.0, 2.0, 4.0],
+    [0.0, 1.0, 2.0],
+    [0.0, 1.5, 3.0],
+]
+radial3 = [
+    [0.075],
+]
+layer_sizes = [
+    [64, 32, 16],
+    [32, 16, 8],
+]
+
+learning_rates = [
+    0.001,
+]
+
+epochs = [10]
+
+
+def params():
+  for values in itertools.product(radial1, radial2, radial3, layer_sizes,
+                                  learning_rates, epochs):
+    d = {
+        "frag1_num_atoms": 140,
+        "frag2_num_atoms": 821,
+        "complex_num_atoms": 908,
+        "radial": [values[0], values[1], values[2]],
+        "layer_sizes": values[3],
+        "learning_rate": values[4],
+        "epochs": values[5]
+    }
+    yield d
+
+
+metric = [
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression"),
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression")
+]
+for param in params():
+  num_epochs = param['epochs']
+  del param['epochs']
+  tg, feed_dict_generator, label = atomic_conv_model(**param)
+  tg.fit_generator(
+      feed_dict_generator(train_dataset, batch_size, epochs=num_epochs))
+
+  test_evaluator = dc.utils.evaluate.GeneratorEvaluator(
+      tg, feed_dict_generator(test_dataset, batch_size), transformers, [label])
+  test_scores = test_evaluator.compute_model_performance(metric)
+  param.update(test_scores)
+  param['epochs'] = num_epochs
+  print("Results")
+  print(param)
+  with open('hyper_results.txt', 'a') as fout:
+    fout.write(json.dumps(param))
+    fout.write("\n")

deepchem/source/contrib/atomicconv/acnn/refined/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

deepchem/source/contrib/atomicconv/acnn/refined/get_acnn_refined.sh

@@ -0,0 +1,4 @@
+echo "Pulling featurized and split ACNN datasets from deepchem"
+wget http://deepchem.io.s3-website-us-west-1.amazonaws.com/featurized_datasets/acnn_refined.tar.gz
+echo "Extracting ACNN datasets"
+tar -zxvf acnn_refined.tar.gz

deepchem/source/contrib/atomicconv/acnn/refined/opt_random.py

@@ -0,0 +1,125 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+__author__ = "Joseph Gomes"
+__copyright__ = "Copyright 2017, Stanford University"
+__license__ = "MIT"
+
+import os
+import sys
+import deepchem as dc
+import numpy as np
+import tensorflow as tf
+
+sys.path.append("../../models")
+from atomicnet_ops import create_symmetry_parameters
+from atomicnet import TensorflowFragmentRegressor
+
+# Set random seeds
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+# Setup directories
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "random_train")
+test_dir = os.path.join(data_dir, "random_test")
+model_dir = os.path.join(base_dir, "random_model")
+
+# Model constants
+frag1_num_atoms = 153
+frag2_num_atoms = 1119
+complex_num_atoms = 1254
+max_num_neighbors = 12
+neighbor_cutoff = 12.0
+
+# Load and transform datasets
+pdbbind_tasks = ["-logKd/Ki"]
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+
+transformers = []
+# convert -logKi to dG = +RTlogKi [kJ/mol]
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+# Atomic convolution variables
+# at = atomic numbers (atom types)
+# radial basis function parameters [cutoff, mean, width]
+at = [
+    1., 6., 7., 8., 9., 11., 12., 15., 16., 17., 19., 20., 25., 26., 27., 28.,
+    29., 30., 34., 35., 38., 48., 53., 55., 80.
+]
+radial = [[1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0],
+          [0.0], [0.4]]
+rp = create_symmetry_parameters(radial)
+
+# Model hyperparameters
+layer_sizes = [32, 32, 16]
+weight_init_stddevs = [1 / np.sqrt(x) for x in layer_sizes]
+bias_init_consts = [0. for x in layer_sizes]
+penalty_type = "l2"
+penalty = 0.
+dropouts = [0.25, 0.25, 0.]
+learning_rate = 0.001
+momentum = 0.8
+batch_size = 24
+
+# Initialize model
+model = TensorflowFragmentRegressor(
+    len(pdbbind_tasks),
+    rp,
+    at,
+    frag1_num_atoms,
+    frag2_num_atoms,
+    complex_num_atoms,
+    max_num_neighbors,
+    logdir=model_dir,
+    layer_sizes=layer_sizes,
+    weight_init_stddevs=weight_init_stddevs,
+    bias_init_consts=bias_init_consts,
+    penalty=penalty,
+    penalty_type=penalty_type,
+    dropouts=dropouts,
+    learning_rate=learning_rate,
+    momentum=momentum,
+    optimizer="adam",
+    batch_size=batch_size,
+    conv_layers=1,
+    boxsize=None,
+    verbose=True,
+    seed=seed)
+
+# Fit model
+model.fit(train_dataset, nb_epoch=10)
+
+# Evaluate model
+metric = [
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression"),
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression")
+]
+train_evaluator = dc.utils.evaluate.Evaluator(model, train_dataset,
+                                              transformers)
+train_scores = train_evaluator.compute_model_performance(metric)
+print("Train scores")
+print(train_scores)
+test_evaluator = dc.utils.evaluate.Evaluator(model, test_dataset, transformers)
+test_scores = test_evaluator.compute_model_performance(metric)
+print("Test scores")
+print(test_scores)

deepchem/source/contrib/atomicconv/acnn/refined/opt_scaffold.py

@@ -0,0 +1,125 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+__author__ = "Joseph Gomes"
+__copyright__ = "Copyright 2017, Stanford University"
+__license__ = "MIT"
+
+import os
+import sys
+import deepchem as dc
+import numpy as np
+import tensorflow as tf
+
+sys.path.append("../../models")
+from atomicnet_ops import create_symmetry_parameters
+from atomicnet import TensorflowFragmentRegressor
+
+# Set random seeds
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+# Setup directories
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "scaffold_train")
+test_dir = os.path.join(data_dir, "scaffold_test")
+model_dir = os.path.join(base_dir, "scaffold_model")
+
+# Model constants
+frag1_num_atoms = 153
+frag2_num_atoms = 1119
+complex_num_atoms = 1254
+max_num_neighbors = 12
+neighbor_cutoff = 12.0
+
+# Load and transform datasets
+pdbbind_tasks = ["-logKd/Ki"]
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+
+transformers = []
+# convert -logKi to dG = +RTlogKi [kJ/mol]
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+# Atomic convolution variables
+# at = atomic numbers (atom types)
+# radial basis function parameters [cutoff, mean, width]
+at = [
+    1., 6., 7., 8., 9., 11., 12., 15., 16., 17., 19., 20., 25., 26., 27., 28.,
+    29., 30., 34., 35., 38., 48., 53., 55., 80.
+]
+radial = [[1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0],
+          [0.0], [0.4]]
+rp = create_symmetry_parameters(radial)
+
+# Model hyperparameters
+layer_sizes = [32, 32, 16]
+weight_init_stddevs = [1 / np.sqrt(x) for x in layer_sizes]
+bias_init_consts = [0. for x in layer_sizes]
+penalty_type = "l2"
+penalty = 0.
+dropouts = [0.25, 0.25, 0.]
+learning_rate = 0.001
+momentum = 0.8
+batch_size = 24
+
+# Initialize model
+model = TensorflowFragmentRegressor(
+    len(pdbbind_tasks),
+    rp,
+    at,
+    frag1_num_atoms,
+    frag2_num_atoms,
+    complex_num_atoms,
+    max_num_neighbors,
+    logdir=model_dir,
+    layer_sizes=layer_sizes,
+    weight_init_stddevs=weight_init_stddevs,
+    bias_init_consts=bias_init_consts,
+    penalty=penalty,
+    penalty_type=penalty_type,
+    dropouts=dropouts,
+    learning_rate=learning_rate,
+    momentum=momentum,
+    optimizer="adam",
+    batch_size=batch_size,
+    conv_layers=1,
+    boxsize=None,
+    verbose=True,
+    seed=seed)
+
+# Fit model
+model.fit(train_dataset, nb_epoch=10)
+
+# Evaluate model
+metric = [
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression"),
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression")
+]
+train_evaluator = dc.utils.evaluate.Evaluator(model, train_dataset,
+                                              transformers)
+train_scores = train_evaluator.compute_model_performance(metric)
+print("Train scores")
+print(train_scores)
+test_evaluator = dc.utils.evaluate.Evaluator(model, test_dataset, transformers)
+test_scores = test_evaluator.compute_model_performance(metric)
+print("Test scores")
+print(test_scores)

deepchem/source/contrib/atomicconv/acnn/refined/opt_stratified.py

@@ -0,0 +1,125 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+__author__ = "Joseph Gomes"
+__copyright__ = "Copyright 2017, Stanford University"
+__license__ = "MIT"
+
+import os
+import sys
+import deepchem as dc
+import numpy as np
+import tensorflow as tf
+
+sys.path.append("../../models")
+from atomicnet_ops import create_symmetry_parameters
+from atomicnet import TensorflowFragmentRegressor
+
+# Set random seeds
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+# Setup directories
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "stratified_train")
+test_dir = os.path.join(data_dir, "stratified_test")
+model_dir = os.path.join(base_dir, "stratified_model")
+
+# Model constants
+frag1_num_atoms = 153
+frag2_num_atoms = 1119
+complex_num_atoms = 1254
+max_num_neighbors = 12
+neighbor_cutoff = 12.0
+
+# Load and transform datasets
+pdbbind_tasks = ["-logKd/Ki"]
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+
+transformers = []
+# convert -logKi to dG = +RTlogKi [kJ/mol]
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+# Atomic convolution variables
+# at = atomic numbers (atom types)
+# radial basis function parameters [cutoff, mean, width]
+at = [
+    1., 6., 7., 8., 9., 11., 12., 15., 16., 17., 19., 20., 25., 26., 27., 28.,
+    29., 30., 34., 35., 38., 48., 53., 55., 80.
+]
+radial = [[1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0],
+          [0.0], [0.4]]
+rp = create_symmetry_parameters(radial)
+
+# Model hyperparameters
+layer_sizes = [32, 32, 16]
+weight_init_stddevs = [1 / np.sqrt(x) for x in layer_sizes]
+bias_init_consts = [0. for x in layer_sizes]
+penalty_type = "l2"
+penalty = 0.
+dropouts = [0.25, 0.25, 0.]
+learning_rate = 0.001
+momentum = 0.8
+batch_size = 24
+
+# Initialize model
+model = TensorflowFragmentRegressor(
+    len(pdbbind_tasks),
+    rp,
+    at,
+    frag1_num_atoms,
+    frag2_num_atoms,
+    complex_num_atoms,
+    max_num_neighbors,
+    logdir=model_dir,
+    layer_sizes=layer_sizes,
+    weight_init_stddevs=weight_init_stddevs,
+    bias_init_consts=bias_init_consts,
+    penalty=penalty,
+    penalty_type=penalty_type,
+    dropouts=dropouts,
+    learning_rate=learning_rate,
+    momentum=momentum,
+    optimizer="adam",
+    batch_size=batch_size,
+    conv_layers=1,
+    boxsize=None,
+    verbose=True,
+    seed=seed)
+
+# Fit model
+model.fit(train_dataset, nb_epoch=10)
+
+# Evaluate model
+metric = [
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression"),
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression")
+]
+train_evaluator = dc.utils.evaluate.Evaluator(model, train_dataset,
+                                              transformers)
+train_scores = train_evaluator.compute_model_performance(metric)
+print("Train scores")
+print(train_scores)
+test_evaluator = dc.utils.evaluate.Evaluator(model, test_dataset, transformers)
+test_scores = test_evaluator.compute_model_performance(metric)
+print("Test scores")
+print(test_scores)

deepchem/source/contrib/atomicconv/acnn/refined/opt_temporal.py

@@ -0,0 +1,125 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+__author__ = "Joseph Gomes"
+__copyright__ = "Copyright 2017, Stanford University"
+__license__ = "MIT"
+
+import os
+import sys
+import deepchem as dc
+import numpy as np
+import tensorflow as tf
+
+sys.path.append("../../models")
+from atomicnet_ops import create_symmetry_parameters
+from atomicnet import TensorflowFragmentRegressor
+
+# Set random seeds
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+# Setup directories
+base_dir = os.getcwd()
+data_dir = os.path.join(base_dir, "datasets")
+train_dir = os.path.join(data_dir, "temporal_train")
+test_dir = os.path.join(data_dir, "temporal_test")
+model_dir = os.path.join(base_dir, "temporal_model")
+
+# Model constants
+frag1_num_atoms = 153
+frag2_num_atoms = 1119
+complex_num_atoms = 1254
+max_num_neighbors = 12
+neighbor_cutoff = 12.0
+
+# Load and transform datasets
+pdbbind_tasks = ["-logKd/Ki"]
+train_dataset = dc.data.DiskDataset(train_dir)
+test_dataset = dc.data.DiskDataset(test_dir)
+
+transformers = []
+# convert -logKi to dG = +RTlogKi [kJ/mol]
+y_train = train_dataset.y
+y_train *= -1 * 2.479 / 4.184
+train_dataset = dc.data.DiskDataset.from_numpy(
+    train_dataset.X,
+    y_train,
+    train_dataset.w,
+    train_dataset.ids,
+    tasks=pdbbind_tasks)
+y_test = test_dataset.y
+y_test *= -1 * 2.479 / 4.184
+test_dataset = dc.data.DiskDataset.from_numpy(
+    test_dataset.X,
+    y_test,
+    test_dataset.w,
+    test_dataset.ids,
+    tasks=pdbbind_tasks)
+
+# Atomic convolution variables
+# at = atomic numbers (atom types)
+# radial basis function parameters [cutoff, mean, width]
+at = [
+    1., 6., 7., 8., 9., 11., 12., 15., 16., 17., 19., 20., 25., 26., 27., 28.,
+    29., 30., 34., 35., 38., 48., 53., 55., 80.
+]
+radial = [[1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0],
+          [0.0], [0.4]]
+rp = create_symmetry_parameters(radial)
+
+# Model hyperparameters
+layer_sizes = [32, 32, 16]
+weight_init_stddevs = [1 / np.sqrt(x) for x in layer_sizes]
+bias_init_consts = [0. for x in layer_sizes]
+penalty_type = "l2"
+penalty = 0.
+dropouts = [0.25, 0.25, 0.]
+learning_rate = 0.001
+momentum = 0.8
+batch_size = 24
+
+# Initialize model
+model = TensorflowFragmentRegressor(
+    len(pdbbind_tasks),
+    rp,
+    at,
+    frag1_num_atoms,
+    frag2_num_atoms,
+    complex_num_atoms,
+    max_num_neighbors,
+    logdir=model_dir,
+    layer_sizes=layer_sizes,
+    weight_init_stddevs=weight_init_stddevs,
+    bias_init_consts=bias_init_consts,
+    penalty=penalty,
+    penalty_type=penalty_type,
+    dropouts=dropouts,
+    learning_rate=learning_rate,
+    momentum=momentum,
+    optimizer="adam",
+    batch_size=batch_size,
+    conv_layers=1,
+    boxsize=None,
+    verbose=True,
+    seed=seed)
+
+# Fit model
+model.fit(train_dataset, nb_epoch=10)
+
+# Evaluate model
+metric = [
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression"),
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression")
+]
+train_evaluator = dc.utils.evaluate.Evaluator(model, train_dataset,
+                                              transformers)
+train_scores = train_evaluator.compute_model_performance(metric)
+print("Train scores")
+print(train_scores)
+test_evaluator = dc.utils.evaluate.Evaluator(model, test_dataset, transformers)
+test_scores = test_evaluator.compute_model_performance(metric)
+print("Test scores")
+print(test_scores)

deepchem/source/contrib/atomicconv/acnn/refined/tensor_graph_hyper_param_eval.py

@@ -0,0 +1,137 @@
+from __future__ import print_function
+from __future__ import division
+from __future__ import unicode_literals
+
+import os
+import sys
+import deepchem as dc
+import json
+import numpy as np
+import tensorflow as tf
+from deepchem.models.atomic_conv import atomic_conv_model
+
+sys.path.append("../../models")
+from deepchem.models.tensorgraph.layers import Layer, Feature, Label, L2Loss, AtomicConvolution, Transpose, Dense
+from deepchem.models import TensorGraph
+
+import numpy as np
+import tensorflow as tf
+import itertools
+import time
+
+seed = 123
+np.random.seed(seed)
+tf.set_random_seed(seed)
+
+base_dir = os.getcwd()
+
+batch_size = 24
+splits = ["random", "stratified", "index", "scaffold"]
+
+
+def params():
+  d2 = {
+      "name":
+      "hyper5",
+      "radial": [[
+          1.5, 2.5, 3.5, 4.5, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5, 10.0,
+          10.5
+      ], [0.0, 2.0, 4.0], [0.05]],
+      "layer_sizes": [32, 16, 8],
+      "learning_rate":
+      0.001,
+      "epochs":
+      10,
+      "frag1_num_atoms":
+      71,
+      "frag2_num_atoms":
+      912,
+      "complex_num_atoms":
+      982,
+  }
+  yield d2
+  d2 = {
+      "name":
+      "original",
+      "radial": [[
+          1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0,
+          8.5, 9.0, 9.5, 10.0, 10.5, 11.0, 11.5, 12.0
+      ], [0.0, 4.0, 8.0], [0.4]],
+      "layer_sizes": [32, 32, 16],
+      "learning_rate":
+      0.001,
+      "epochs":
+      10,
+      "frag1_num_atoms":
+      71,
+      "frag2_num_atoms":
+      912,
+      "complex_num_atoms":
+      982,
+  }
+  yield d2
+
+
+metric = [
+    dc.metrics.Metric(dc.metrics.mean_absolute_error, mode="regression"),
+    dc.metrics.Metric(dc.metrics.pearson_r2_score, mode="regression")
+]
+for split in splits:
+  data_dir = os.path.join(base_dir, "datasets")
+  train_dir = os.path.join(data_dir, "%s_train" % split)
+  valid_dir = os.path.join(data_dir, "%s_valid" % split)
+  test_dir = os.path.join(data_dir, "%s_test" % split)
+
+  train_dataset = dc.data.DiskDataset(train_dir)
+  valid_dataset = dc.data.DiskDataset(train_dir)
+  test_dataset = dc.data.DiskDataset(test_dir)
+  pdbbind_tasks = ["-logKd/Ki"]
+  transformers = []
+
+  y_train = train_dataset.y
+  y_train *= -1 * 2.479 / 4.184
+  train_dataset = dc.data.DiskDataset.from_numpy(
+      train_dataset.X,
+      y_train,
+      train_dataset.w,
+      train_dataset.ids,
+      tasks=pdbbind_tasks)
+
+  y_test = test_dataset.y
+  y_test *= -1 * 2.479 / 4.184
+  test_dataset = dc.data.DiskDataset.from_numpy(
+      test_dataset.X,
+      y_test,
+      test_dataset.w,
+      test_dataset.ids,
+      tasks=pdbbind_tasks)
+  for param in params():
+    num_epochs = param['epochs']
+    del param['epochs']
+    name = param['name']
+    del param['name']
+
+    tg, feed_dict_generator, label = atomic_conv_model(**param)
+    for i in range(2):
+      tg.fit_generator(
+          feed_dict_generator(train_dataset, batch_size, epochs=num_epochs))
+
+      valid_evaluator = dc.utils.evaluate.GeneratorEvaluator(
+          tg,
+          feed_dict_generator(valid_dataset, batch_size), transformers, [label])
+      valid_scores = valid_evaluator.compute_model_performance(metric)
+      valid_scores = {"%s_valid" % k: v for k, v in valid_scores.items()}
+      param.update(valid_scores)
+      # test_evaluator = dc.utils.evaluate.GeneratorEvaluator(
+      #   tg, feed_dict_generator(test_dataset, batch_size), transformers, [label])
+      # test_scores = test_evaluator.compute_model_performance(metric)
+      # test_scores = {"%s_test" % k: v for k, v in test_scores.items()}
+      # param.update(test_scores)
+      param['epochs'] = num_epochs * (i + 1)
+      param['split'] = split
+      param['name'] = name
+      print("Results")
+      print(param)
+      with open('hyper_evaluation.txt', 'a') as fout:
+        fout.write(json.dumps(param))
+        fout.write("\n")