Upload 16 files

Dockerfile

@@ -0,0 +1,320 @@
+FROM python:3.8
+
+# Install required system dependencies
+RUN apt-get update && apt-get install -y libopenblas-dev git curl && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create necessary directories (but don't download models here!)
+RUN mkdir -p /app/modelsBioembed /app/models_folder /app/Samples
+
+# Copy the entire project to the container
+COPY . .
+
+# Expose the port for Flask
+EXPOSE 7860
+
+# Run the app with Gunicorn
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "app:app"]
+
+
+# # Use Python 3.8 as the base image
+# FROM python:3.8
+
+# # Install required system dependencies
+# RUN apt-get update && apt-get install -y libopenblas-dev git wget && rm -rf /var/lib/apt/lists/*
+
+# # Set the working directory inside the container
+# WORKDIR /app
+
+# # Copy the requirements file into the container
+# COPY requirements.txt .
+
+# # Install dependencies
+# RUN pip install --no-cache-dir -r requirements.txt
+
+# # Create necessary directories inside the container
+# RUN mkdir -p /app/modelsBioembed /app/models_folder /app/Samples
+
+# # Download model files from Dropbox using wget
+# RUN wget -O /app/modelsBioembed/pytorch_model.bin "https://www.dropbox.com/scl/fi/b41t8c6ji7j6uk5y2jj8g/pytorch_model.bin?rlkey=kuuwkid36ugml560c4a465ilr&st=t60bfemx&dl=1" && \
+#     wget -O /app/modelsBioembed/config.json "https://www.dropbox.com/scl/fi/js6czj3kfc4a5kshfkzie/config.json?rlkey=5oysq4ecilnan5tviuqe86v93&st=75zpce8h&dl=1" && \
+#     wget -O /app/modelsBioembed/special_tokens_map.json "https://www.dropbox.com/scl/fi/t3lvmp5x28d1zjac3j7ec/special_tokens_map.json?rlkey=z2xbompa54iu4y9qgb5bvmfc9&st=zrxlpjdt&dl=1" && \
+#     wget -O /app/modelsBioembed/tokenizer_config.json "https://www.dropbox.com/scl/fi/x11poym6mueoxod7xb6f1/tokenizer_config.json?rlkey=s51pik2rkmqp1fu99qj9qaria&st=z9kkcxp7&dl=1" && \
+#     wget -O /app/modelsBioembed/vocab.txt "https://www.dropbox.com/scl/fi/v6e2gn10ck4lpx4iv9kpe/vocab.txt?rlkey=dcu29g5ns4wtqdv0pkks0ehx1&st=qt187rhq&dl=1"
+
+# # Copy the entire project to the container
+# COPY . .
+
+# # Expose the port for Flask
+# EXPOSE 8000
+
+# # Run the app with Gunicorn
+# CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
+
+
+
+
+# # Use Python 3.8 as the base image
+# FROM python:3.8
+
+# # Install required system dependencies
+# RUN apt-get update && apt-get install -y libopenblas-dev git wget && rm -rf /var/lib/apt/lists/*
+
+# # Set the working directory inside the container
+# WORKDIR /app
+
+# # Copy the requirements file into the container
+# COPY requirements.txt .
+
+# # Install dependencies
+# RUN pip install --no-cache-dir -r requirements.txt
+
+# # Create necessary directories inside the container
+# RUN mkdir -p /app/modelsBioembed /app/models_folder /app/Samples
+
+# # Download model files from Dropbox using wget
+# RUN wget -O /app/modelsBioembed/pytorch_model.bin "https://www.dropbox.com/s/example/pytorch_model.bin?dl=1" && \
+#     wget -O /app/modelsBioembed/config.json "https://www.dropbox.com/s/example/config.json?dl=1" && \
+#     wget -O /app/modelsBioembed/tokenizer_config.json "https://www.dropbox.com/s/example/tokenizer_config.json?dl=1" && \
+#     wget -O /app/modelsBioembed/vocab.txt "https://www.dropbox.com/s/example/vocab.txt?dl=1" && \
+#     wget -O /app/modelsBioembed/special_tokens_map.json "https://www.dropbox.com/s/example/special_tokens_map.json?dl=1"
+
+# # Copy the entire project to the container
+# COPY . .
+
+# # Expose the port for Flask
+# EXPOSE 8000
+
+# # Run the app with Gunicorn
+# CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
+
+
+
+
+
+
+
+
+
+
+
+
+
+# # Use Python 3.8 as the base image
+# FROM python:3.8
+
+# # Install required system dependencies
+# RUN apt-get update && apt-get install -y libopenblas-dev git curl && rm -rf /var/lib/apt/lists/*
+
+# # Set the working directory inside the container
+# WORKDIR /app
+
+# # Copy the requirements file into the container
+# COPY requirements.txt .
+
+# # Install dependencies
+# RUN pip install --no-cache-dir -r requirements.txt
+
+# # Install gdown for Google Drive downloads
+# RUN pip install --no-cache-dir gdown
+
+# # Create necessary directories inside the container
+# RUN mkdir -p /app/modelsBioembed /app/models_folder /app/Samples
+
+# # Download model files from Google Drive using gdown
+# RUN gdown --id 1aDirthtWAu-oyVjcWZ6linrddN-dmLMI -O /app/modelsBioembed/pytorch_model.bin && \
+#     gdown --id 1bwk1fSwqQE5mN9AhsOBlQkvFjHCGQtJ3 -O /app/modelsBioembed/config.json && \
+#     gdown --id 1ne-xJcySd8PcGTA4SdpTA6F869xsPiTf -O /app/modelsBioembed/tokenizer_config.json && \
+#     gdown --id 1tWjWsoeyPvTdW5sYZMSWpvISlN7tDoZ -O /app/modelsBioembed/vocab.txt && \
+#     gdown --id 1M8Qg9fSQ2A7CZpVFMCrZMIwam2j6Cc6P -O /app/modelsBioembed/special_tokens_map.json
+
+# # Copy the entire project to the container
+# COPY . .
+
+# # Expose the port for Flask
+# EXPOSE 8000
+
+# # Run the app with Gunicorn
+# CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
+# #Use Python 3.8 as the base image
+# FROM python:3.8
+
+# # Install required system dependencies
+# RUN apt-get update && apt-get install -y libopenblas-dev git curl && rm -rf /var/lib/apt/lists/*
+
+# # Set the working directory inside the container
+# WORKDIR /app
+
+# # Copy the requirements file into the container
+# COPY requirements.txt .
+
+# # Install dependencies
+# RUN pip install --no-cache-dir -r requirements.txt
+
+# # Install gdown for Google Drive downloads
+# RUN pip install --no-cache-dir gdown
+
+# # Create necessary directories inside the container
+# RUN mkdir -p /app/modelsBioembed /app/models_folder /app/Samples
+
+# # Download model files from Google Drive using alternative methods
+# RUN curl -L -o /app/modelsBioembed/pytorch_model.bin "https://drive.google.com/uc?export=download&id=11g7bAXYNxlPsnwC8_qsUIZITAjG85JXb" && \
+#     curl -L -o /app/modelsBioembed/config.json "https://drive.google.com/uc?export=download&id=1ZfuhTnEuKAI1Z92m1QnDTOEQYNe9y24E" && \
+#     curl -L -o /app/modelsBioembed/tokenizer_config.json "https://drive.google.com/uc?export=download&id=1r4ncUsWBNQZVKp4zw97DLTf0AgRUiuFc" && \
+#     curl -L -o /app/modelsBioembed/vocab.txt "https://drive.google.com/uc?export=download&id=1G1UQIGMHvCC3OokCG1tl-cTxjIVqw04w" && \
+#     curl -L -o /app/modelsBioembed/special_tokens_map.json "https://drive.google.com/uc?export=download&id=1pINnV2P1eBmaC7X0A52UhjrmlJgzxqbl"
+
+# # Copy the entire project to the container
+# COPY . .
+
+# # Expose the port for Flask
+# EXPOSE 8000
+
+# # Run the app with Gunicorn
+# CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
+
+
+
+
+# # Use Python 3.8 as the base image
+# FROM python:3.8
+
+# # Install required system dependencies
+# RUN apt-get update && apt-get install -y libopenblas-dev git curl wget && rm -rf /var/lib/apt/lists/*
+
+# # Set the working directory inside the container
+# WORKDIR /app
+
+# # Copy the requirements file into the container
+# COPY requirements.txt .
+
+# # Install dependencies
+# RUN pip install --no-cache-dir -r requirements.txt
+
+# # Create necessary directories inside the container
+# RUN mkdir -p /app/modelsBioembed /app/models_folder /app/Samples
+
+# # Function to download file from Google Drive using wget
+# RUN wget --no-check-certificate 'https://drive.google.com/uc?export=download&id=11g7bAXYNxlPsnwC8_qsUIZITAjG85JXb' -O /app/modelsBioembed/pytorch_model.bin && \
+#     wget --no-check-certificate 'https://drive.google.com/uc?export=download&id=1ZfuhTnEuKAI1Z92m1QnDTOEQYNe9y24E' -O /app/modelsBioembed/config.json && \
+#     wget --no-check-certificate 'https://drive.google.com/uc?export=download&id=1r4ncUsWBNQZVKp4zw97DLTf0AgRUiuFc' -O /app/modelsBioembed/tokenizer_config.json && \
+#     wget --no-check-certificate 'https://drive.google.com/uc?export=download&id=1G1UQIGMHvCC3OokCG1tl-cTxjIVqw04w' -O /app/modelsBioembed/vocab.txt && \
+#     wget --no-check-certificate 'https://drive.google.com/uc?export=download&id=1pINnV2P1eBmaC7X0A52UhjrmlJgzxqbl' -O /app/modelsBioembed/special_tokens_map.json
+
+# # Copy the entire project to the container
+# COPY . .
+
+# # Expose the port for Flask
+# EXPOSE 8000
+
+# # Run the app with Gunicorn
+# CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
+
+
+# # Use Python 3.8 as the base image
+# FROM python:3.8
+
+# # Install required system dependencies
+# RUN apt-get update && apt-get install -y libopenblas-dev git curl && rm -rf /var/lib/apt/lists/*
+
+# # Set the working directory inside the container
+# WORKDIR /app
+
+# # Copy the requirements file into the container
+# COPY requirements.txt .
+
+# # Install dependencies
+# RUN pip install --no-cache-dir -r requirements.txt
+
+# # Install gdown for Google Drive downloads
+# RUN pip install --no-cache-dir gdown
+
+# # Create necessary directories inside the container
+# RUN mkdir -p /app/modelsBioembed /app/models_folder /app/Samples
+
+# # Download model files using gdown with file IDs
+# RUN gdown --id 1aDirthtWAu-oyVjcWZ6linrddN-dmLMI -O /app/modelsBioembed/pytorch_model.bin && \
+#     gdown --id 1bwk1fSwqQE5mN9AhsOBlQkvFjHCGQtJ3 -O /app/modelsBioembed/config.json && \
+#     gdown --id 1ne-xJcySd8PcGTA4SdpTA6F869xsPiTf -O /app/modelsBioembed/tokenizer_config.json && \
+#     gdown --id 1tWjWsoeyPvTdW5sYZMSWpvISlN7tDoZ -O /app/modelsBioembed/vocab.txt && \
+#     gdown --id 1M8Qg9fSQ2A7CZpVFMCrZMIwam2j6Cc6P -O /app/modelsBioembed/special_tokens_map.json
+
+# # Copy the entire project to the container
+# COPY . .
+
+# # Expose the port for Flask
+# EXPOSE 8000
+
+# # Run the app with Gunicorn
+# CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# # Use Python 3.8 as the base image
+# FROM python:3.8
+
+# # Install required system dependencies
+# RUN apt-get update && apt-get install -y libopenblas-dev git curl && rm -rf /var/lib/apt/lists/*
+
+# # Set the working directory inside the container
+# WORKDIR /app
+
+# # Copy the requirements file into the container
+# COPY requirements.txt .
+
+# # Install dependencies
+# RUN pip install --no-cache-dir -r requirements.txt
+
+# # Create necessary directories inside the container
+# RUN mkdir -p /app/modelsBioembed /app/models_folder /app/Samples
+
+# # Set the OAuth 2.0 Access Token (Replace with your actual token)
+# ENV ACCESS_TOKEN="ya29.a0AeXRPp6PRilVeuzghPDbZQE7DxYHHWv4TARoaumWuo4gX9bIcEtMzp3PGi1Ak36YIbvKk32V7Cwb6bEjGfJuOWp0ZDW5rdog1c5uf9PJH7b-zgPxIeGa0kmZhGlk79gc7WfoSAl-GUopljJfOmKsyVn628CGB10RRHBtMQiHaCgYKARQSARESFQHGX2MiRd-59J4_XHWekXXqwK-jsw0175"
+
+# # Define Google Drive File IDs
+# ENV FILE_ID1="1aDirthtWAu-oyVjcWZ6linrddN-dmLMI"
+# ENV FILE_ID2="1bwk1fSwqQE5mN9AhsOBlQkvFjHCGQtJ3"
+# ENV FILE_ID3="1ne-xJcySd8PcGTA4SdpTA6F869xsPiTf"
+# ENV FILE_ID4="1tWjWsoeyPvTdW5sYZMSWpvISlN7tDoZ"
+# ENV FILE_ID5="1M8Qg9fSQ2A7CZpVFMCrZMIwam2j6Cc6P"
+
+# # Download model files using curl with OAuth token
+# RUN curl -H "Authorization: Bearer $ACCESS_TOKEN" "https://www.googleapis.com/drive/v3/files/$FILE_ID1?alt=media" -o /app/modelsBioembed/pytorch_model.bin && \
+#     curl -H "Authorization: Bearer $ACCESS_TOKEN" "https://www.googleapis.com/drive/v3/files/$FILE_ID2?alt=media" -o /app/modelsBioembed/config.json && \
+#     curl -H "Authorization: Bearer $ACCESS_TOKEN" "https://www.googleapis.com/drive/v3/files/$FILE_ID3?alt=media" -o /app/modelsBioembed/tokenizer_config.json && \
+#     curl -H "Authorization: Bearer $ACCESS_TOKEN" "https://www.googleapis.com/drive/v3/files/$FILE_ID4?alt=media" -o /app/modelsBioembed/vocab.txt && \
+#     curl -H "Authorization: Bearer $ACCESS_TOKEN" "https://www.googleapis.com/drive/v3/files/$FILE_ID5?alt=media" -o /app/modelsBioembed/special_tokens_map.json
+
+# # Copy the entire project to the container
+# COPY . .
+
+# # Expose the port for Flask
+# EXPOSE 8000
+
+# # Run the app with Gunicorn
+# CMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]
+

Samples/SMILES_GENERATED.txt

@@ -0,0 +1,95 @@
+CC(C)C1C(=O)NC2CCN(CCC3CCC(CN)CC3)C21
+CCOC(=O)C1CCCCCC12CCCCN2
+O=C(O)CCNC(=O)C1NCCCC1C(=O)NO
+CC(C)CC(NC(=O)C(Cc1c[nH]cn1)NC(=O)c1cccc(C(F)(F)F)c1)C(=O)O
+CC(=O)OC1CC2CC(CC(c3ccc(O)c(O)c3)=C2O)OC(=O)c2ccc1c(O)c2
+Cc1cc2cc(C)n(O)c(=O)c2cc1C
+NCCc1ccc(S(=O)(=O)N2CCN=C2c2ccc(-c3ccccc3)cc2)cc1
+NC1=NC(c2c(Cl)cc(Cl)cc2Cl)CC(=O)N1
+CC=NOC(=O)c1ccc(NS(=O)(=O)N=C2c3ccc(C)cc3CCC2(C)C)cc1
+CC(=O)CCCC(=O)OCC(CNc1cccc(Cl)c1)S(=O)(=O)O
+CN(CCF)c1ccc(C(=O)NC(CN2C(=O)C3CCCCC3(C)C2=O)c2ccccc2)cc1
+Cc1ccc(CNC(=O)C2CC(O)CC(C)C2CN2CCc3ccccc32)cc1
+CC(=O)C(C(C)=NO)=C(O)c1ccccc1Sc1ccccc1CO
+CNCCCCNC(=O)c1c(-c2ccccc2Cl)n[nH]c1-c1ccccc1Cl
+CCOC(=O)c1c(CO)ccc(O)c1C
+CCOc1ccc(F)c(CC(=O)NC2Cc3ccccc3C2)c1
+Cc1ncc(CNC(=O)C2(c3cccc(F)c3)CCN(C)CC2)c(NCc2ccc(C#N)cc2)n1
+CCn1cc(C=NNC(=O)c2ccc(Cl)cc2C(F)(F)F)n2ccc(=O)nc12
+NC(=O)C1CCCN1c1cc(-c2nc(N)c3cc(C(F)(F)F)cnc3n2)cc(C(F)(F)F)c1
+CC(C)Oc1ccn2c(N)nc(N3CCN(CC(N)=O)CC3)nc12
+CC1(C)Cc2cc(c(C(=O)Nc3ccc(Cl)c(Cl)c3)nc2-c2cccnc2)N1
+CCOC(=O)C1(CCCCCC=C(C)C)CCN(C(=O)CCC(=O)O)CC1
+CCN1C(=O)C2CCCCC2C(C#N)=C1Nc1ccncc1
+CCn1c(C(=O)N2CCN(C(=O)c3ccc(C(F)(F)F)cc3)CC2)c(O)c2ccccc21
+O=C(N1CCNCC1)n1cc2c(=O)[nH]c(=S)[nH]n2c1=O
+CC(C)C(O)CC(O)C(=O)c1nn2c(=O)cc(C(F)(F)F)nc2s1
+Nc1c2c(nn1-c1ncc(C(F)(F)F)cn1)Cc1ccccc1C2=O
+Nc1cc(-c2cnc(N)nc2-c2ccc(F)cc2)ncn1
+CC1CCN(C(=O)C2NC(=O)C(c3cccs3)C2(C)C)CC1
+Nc1cc(OCC(=O)c2ccc(Cl)c(Cl)c2)ncn1
+CCOc1ccc2c(c1)CC(CCN1CCN(C(=O)c3ccn(Cc4cc(O)ccc4O)n3)CC1)C2=O
+Cc1ncc([N+](=O)[O-])n1CCN1CCCN(C(=O)c2ccc3nccnc3c2)CC1
+Cn1c(C(=O)NC2CCC(C(N)=O)CC2)nc2cc(N=C(N)c3ccc(Cl)cc3Cl)ncc21
+Nc1ccc(NC(=O)c2cnc(N)nc2N)cn1
+CCN1CCN(C(=O)c2sc(S(=O)(=O)NCc3cccnc3N3CCNCC3)cc2C)CC1
+CCOCC(=O)N(c1c(O)nc(=O)[nH]c1C)C1CCCCC1
+CCC(=Nc1[nH]nc(-c2cccc(OC)c2)c1-c1ccncc1)N(C)C
+Cc1nn(-c2cccc(NC(=O)c3ccc(F)c([N+](=O)[O-])c3)c2)c2c1CCN(C(C)(C)C(=O)N(C)C)C2=O
+CCC1CC=CC(=O)N2CC(C3CCCCC3)N(C(=O)c3ccc(C(F)(F)F)cc3)CC2C(=O)OC1
+CCC(CCN1CCN(C(=O)c2ccc(C#N)nc2)CC1)N(C)C
+CC(=O)c1ccc(S(=O)(=O)n2ccc(-c3c(C)nc(-c4ccc([N+](=O)[O-])cc4)oc3=O)n2)cc1
+Cc1cc(O)ccc1C(O)C1C(=O)NC1C(=O)NC1(C(C)C)CC2CN(Cc3ccncc3)CCN2C1=O
+O=C(NC1CCS(=O)(=O)C1)c1cnc(Nc2ccc(Oc3ccccc3)cc2)cn1
+CC(C)CCC1N(C(=NC2CCS(=O)(=O)C2)SCc2cccnc2)C(=O)CC1(C)C
+CC(=O)OC(Cc1ccc(C(C)=O)cc1)C(C)N(O)C=O
+CCCC(=O)N1CCCC(N)C1
+CCN(CC)CCN=c1c(O)c(O)c1=Nc1ccc(C(C)(O)C(F)(F)F)cc1
+O=C(NO)c1cc2c3n(nc2oc1=O)CC(CCO)CN3CC1CCCCC1
+CC1=NCC(C)(C)c2cnc(S(C)(=O)=O)nc21
+Cc1cc(C)nc(C(=O)N2CC3c4ccc(OCC#CC5(C(N)=O)CCCC5)cc4N(C)CC2C3C(=O)O)c1
+Cc1sc2nc(CN(CC3CCCCC3)C(=O)N3c4ccccc4C(=O)C3F)nn2c1C
+Cc1cccc(CN2CCN(CC(O)Cc3c(-c4ccc(F)cn4)nc4ccccn34)CC2)c1
+Cc1ccc2oc(=O)cc(CNC(=O)CNC(=O)Oc3ccc([N+](=O)[O-])cc3)c2c1
+NC([PH](=O)O)S(=O)(=O)O
+O=C(CCN1CCNC1=O)Nc1cccs1
+Cc1nc(CS(=O)(=O)c2ccc(C(F)(F)C(F)(F)F)nc2)c2oc(CC3CCN(C)CC3)nc2c1C(=O)NC(C)C(=O)O
+N#Cc1c(N2CCN(C(=O)c3ccccc3)CC2)nn2c(N)c3c(nc12)CCCC3
+Nc1ncnc2c(-c3ccc(OC(F)(F)F)cc3)c(O)c(C(F)(F)F)nc12
+Cc1ccn(-c2cc3c(c(OC4CCOCC4)c2)Cc2c(N)ncnc2N3)n1
+CC(N=C=S)(c1cccnc1)c1cc(F)ccc1F
+Cn1cnc2cc(-c3ccc(CCO)nc3)nc(-n3cnnc3)c2c1=O
+CCOC(=O)C(CCCC1CCCC(O)C1)N1C(=O)C2C[SH]1C(c1ccc(Cl)c(Cl)c1)=N2
+CC(C)C1C(=O)NC(C2Cc3ccccc3C2)C(=O)NC1C(=O)O
+Cc1c([N+](=O)[O-])c(=O)oc2cc(NC(=O)Nc3ccc(C#N)cc3)ccc12
+CCC(C)n1cnc2c(Sc3ccc(C(F)(F)F)cc3[N+](=O)[O-])nc(N)nc21
+Nc1nnc(Sc2ccccc2Cl)s1
+Cc1cc(O)c(C=O)cc1C(=O)NCCCCCCCN
+Cc1cc(C)n(Cc2cc(C(=O)NC3CCCC3C(=O)NCCCF)ccc2Cl)n1
+CC(C)CCCC(C)CS(=O)(=O)CCCC(N)Cc1cnn(C2=COCOC2)n1
+CCOC(=O)C1CCCN(CC)C1c1cc2c(=O)[nH]cc(CC)c2cc1O
+Nc1nn2c(=O)cc(CSc3nc4ccc(C(=O)O)cc4[nH]3)nc2s1
+CC(=O)Oc1ccc(C#CC=C(C)C(=O)NC(CN=C(N)N)C(C)C)cc1
+CC(C)=NC(=O)c1c(C)n2nc(C(F)(F)F)sc2[n+]1[O-]
+Nc1cc(Cl)ccc1C(=O)NCCNCC(O)CCO
+Cc1noc(-c2ccccc2C(=O)N2CCN3CCC2C(C)(C)C3=O)n1
+CC(=O)OC(c1cccc(C(F)(F)F)c1)C(O)CC1CCN(C)C1CS(=O)(=O)c1ccccc1
+CC(=O)N1CCN(Cc2c(-c3ccccc3)nn(C)c2Cl)CC1
+Nc1ncnc(Oc2cccc(Cc3ccccc3O)c2)c1C(F)(F)F
+Cc1cc(NCCC(=O)Nc2ccc3c(c2)S(=O)(=O)N(C)C3=O)n2nc(C)c(-c3ccccc3)c2n1
+Nc1ncnc2ccc(F)c(-c3csc(C(N)(CO)C(F)(F)F)n3)c12
+CCCCCCCC=C(C)C(=O)NC1CNC(=O)C1
+CC(C)C(C)C(=O)NC1CCN(c2ncnc(NC(C)C3CCCCC3)c2F)C1
+CCc1nnc(CNc2nc(C)cc(N(C)C)n2)o1
+CCOC(=O)Nc1ccc(OCCC(=O)O)nc1
+Cc1cc(-c2nnc(C(=O)NC3CCCCCCC3)o2)ccn1
+Cc1nc(CCCC(=O)C2CC(N)C(=O)NC2C(=O)N2C(C#N)CCC2C#N)cs1
+Cn1cnc2c(Nc3ccn(C4CCC5CC(CO)C(=O)NC54)c(=O)n3)nc(-c3c(N)cc(Cl)cc3Cl)nc21
+CCc1[nH]ncc1C(=O)N1CCC(C)CC1C(=O)NCc1ccc(N(C)C)cc1
+CC(C)=CCOC1Cc2c(c(O)nc3ccccc23)CO1
+CCCNCCCOc1cccc(-c2cccc(OC)c2)c1
+CC(C)CC(C=O)NC(=O)C(CC1CCCC1)NC(=O)NC1CCCCCC1
+Nc1cc2n(c(=O)n1)C1CCCCCC(C1)N2
+NC(=O)c1cccc(-c2cnc3ccc(Nc4ccncn4)nn23)c1
+CC(=O)OC1CCC(OC(C)=O)C(CNC(=S)Nc2ccc(F)c(Cl)c2)C1
+CC(=O)N1CCC2(C)Oc3ccc4c(=O)c(C(=O)O)c(-n5ccnn5)oc4c3C(c3ccccn3)C2C1

Samples/generated_smiles.txt

@@ -0,0 +1,93 @@
+CC(=O)OC1OCCCC1Cl
+O=C1NC(c2ccc(C(F)(F)F)cc2)S(=O)(=O)C1CCCN1CCC2C(Cc3ccccc3C23NC(=S)NC3=O)CC1CO
+Nc1nc(-c2ccccc2)nc2ccc(C(F)(F)F)cc12
+CCNCC(O)(c1ccc2c(c1)NCCC2)C(C)C
+NC(=O)C1CCC(CCO)C2Cc3cccc([N+](=O)[O-])c3-c3ccccc3CC(=O)N12
+CC(C)CC1OC2CC3CN(C(=O)C24CC=C1CN4)C(c1ccccc1[N+](=O)[O-])C(=O)N3
+CCn1cc(C(=O)O)c(=O)c2c3ccccc3n(CCl)c21
+Cc1[nH]c2c(NC(C)c3ccc(C(=O)O)cc3)ncnc2c1C(=O)O
+Cc1cc(C=NOC(C)CNCCCC2CCC(n3cnc4c(N)ncnc43)O2)c2[nH]c(C)cc2n1
+Cc1[nH]n(-c2cc(C(=O)NC(C)C(=O)N(Cc3ccncc3)C3CCCC3F)ccn2)c(=O)c1[N+](=O)[O-]
+CN(Cc1cc2ccoc(=O)c2n1-c1cccc(O)c1)c1ccccc1
+CC(C)C(c1ccc(Cl)cc1O)S(=O)(=O)N(C#N)CC(=O)NO
+NC(=O)c1ccc(N2CCCC(c3cccc(F)c3)C2)nc1C(Cl)(Cl)Cl
+CC(C)C1C(=O)C(O)(c2ccc([N+](=O)[O-])cc2)CC1NC(=O)C1CC(=O)N1
+CCCCNCC1CCOC(c2ccc(F)cc2)O1
+Cc1cc(NC(=O)C2COC(OCCCC(C)C(O)(c3ccccc3)c3ccccc3)C2)ncn1
+Cc1ccc(C(=O)Nc2ccnc(Cn3nc(C)c4c3CCN(Cc3ccccc3)C4)n2)cc1
+CC(=O)C1CCC(C)N1C(=O)OC1CN(C2(c3cccnn3)CCCCC2)CCC1CC(=O)O
+CCC(=O)N1CC2CCCN(CC(=O)NCC3CCN(c4ncncc4F)CC3)C2C1
+CC1(c2ccc(O)cc2)CC(=O)N(C=C(Cl)Cl)C(c2cccnc2)N1
+O=C(Nc1ccc([N+](=O)[O-])cc1C(=O)NN=Cc1cccs1)c1ccc(Cl)s1
+Cc1cc(C)n(-c2nc(N)cc(-c3cc(C(=O)NC4CCNCC4)cc(C(F)(F)F)c3)n2)n1
+CC(=O)OCC1CN(Cc2cccc([N+](=O)[O-])c2)C(CN2CCCC2)C1O
+CC(=O)Nc1c(N)n(CC2CCCO2)c(=O)[nH]c1=O
+Cc1cc(O)nc(N2CCCC(N3CCN(C(=O)c4ccc(F)cc4)CC3)C2)n1
+CC(C)CC(N)C(O)C#N
+NC(=O)C1CCC(CN2CCCCC2)N1C(=O)c1cc(-c2ccnc(N)n2)cc(C(F)(F)F)c1F
+CC(C)(N)CCCNc1cc(C(C)(C)C)ncn1
+Nc1nc(N)c2c(-c3ccccc3)cc(S(=O)(=O)NC(=O)CC3CCCC3)cc2n1
+O=C(NCc1cnn(-c2ccc(F)cc2)c1)c1cccnc1C(F)(F)F
+Cc1nc(-c2ccccn2)c(CSC(=NCc2cccnc2)N2CC(C)(C)CC2=O)s1
+NC(=O)C1CCC2CN(C(=O)OCc3ccc(F)cc3)CC(CO)C21
+CCC(C)CC=CC(CCO)OC(=O)c1cc(S(N)(=O)=O)cnc1C(F)(F)F
+CCn1cc(C)c2nc(-c3cnn(C)c3NCc3cccnc3OC)cnc21
+N#Cc1cc(F)c(N2CCC(CN)C2)cc1NS(=O)(=O)c1cc(Cl)cc(Cl)c1
+CCCCNc1c(C(=O)O)cc2nc(C#N)c(-c3ccccc3)nn12
+CC#CCCCn1c(=O)c(NC(=O)c2cccc(F)c2)cn(CC(=O)NCC2CCCO2)c1=O
+CCn1ncc(S(=O)(=O)c2ccc(C(=O)O)cc2)c1C(=O)Nc1cc(C)cc(C)c1
+NC1CCCCC1C(=O)NCC(=O)NC1CCCCCCC1
+Cc1cc(N2CCOCC2)nc(Nc2ccc(-c3cnc4ccn(C)c4c3)cc2)n1
+CCOC(=O)Nc1nccnc1N1CCC(C(N)=O)CC1
+Cc1c2nc(NC3CCC(CC(N)C(=O)O)CC3)nc(Oc3ccc(C(=O)NCC4CCCCC4)cc3)c2nn1C
+CCC(C(=O)NC1CCCc2cccnc21)N(CCC1CCCCC1)S(=O)(=O)c1cccs1
+CCCCN1C(=O)N=C(Nc2cccc(OCc3ccncc3)c2)C1CC1CCCC1
+Nc1nccn2c(-c3cccnc3)c(CNc3ccc(F)cc3F)cc12
+CC1CCC(NC(=O)c2ccc(CN(c3ccc(C(=O)O)cc3)S(=O)(=O)c3ccc(F)cc3C(F)(F)F)cc2)CC1
+CC=Cc1ccc(S(=O)(=O)N2CCCC2C(=O)N2CC3(O)CCCC3C2=O)cc1
+Cc1ccc(C(=O)N2Cc3nc(-c4ccc(F)cc4)ncc3C2=NN(C(=O)C2CCCC(C(N)=O)C2)C2CCNC2)cc1C
+CCCCCCNCCc1cc(CC)cc(=O)o1
+CC(=O)NC1CCC(CCCCOCCNC(=O)C2CCCN2C(=O)OC(C)(C)C)CC1
+CCCNc1ccc(Cl)cc1C(=O)NC(C)CC(C)C
+CCC(C(O)C1C(O)=C(C)OC(=S)N1CCC(O)C(C)(C)C)S(=O)(=O)CC
+CCCCNC(=O)OC1CC2CCC(c3nnc4ccccn34)CCN2C1O
+CC(C)N1CC(C(=O)Nc2ccc(N3CCOCC3)c([N+](=O)[O-])c2)C2CS(=O)(=O)CC21
+CCCCCCCN1CC2COC1C(O)(Cn1c(-c3cccs3)nc3c(N)ncnc31)C2
+Nc1nc(Sc2ccc(C(F)(F)F)cc2)nc2cccc(-c3ccc(C(=O)O)nc3)c12
+O=c1oc2ccccc2n1CCS(=O)(=O)N1CCCCCC1
+NCCNc1ncnc(N)c1C(=O)NC1CCCC1
+N=C(N)OCCOCc1c(N)ccc2c1CC(O)CC2
+CN1CCN(C(=O)C2CCN(C3CC(C)(C)c4ccc(C(=O)O)c3c4)CC2)CC1
+CC(=O)N(C1=NC(=O)C(CC2CCC2OC(N)=O)N1CC(C)(C)c1ccccc1)C1CCCC1
+CC(=O)NCCNCCCCCC(=O)c1ccc(-c2cc(Cl)cc(Cl)c2)o1
+CCNS(=O)(=O)c1cccc(COc2ccnnc2)c1
+O=C(NN=CCc1ccco1)c1cnccn1
+Cc1cccc(N(C)CCC(=O)C2C(=O)OC3CC(C(=O)O)NCC3C2C(F)(F)F)c1C
+Cc1cc(Sc2ccncc2)c([N+](=O)[O-])c(C)n1
+Cc1c(Cl)ccc2[nH]c(=O)c(-n3c([N+](=O)[O-])cnc3C)nc12
+Cc1ccc(C#N)cc1C1N=C(c2ccc(S(N)(=O)=O)cc2)CC(=O)N1C
+CCOC(=O)C1CCC(Cn2c(C(C)(C)C)ccc(C#N)c2=N)C1
+Cc1nn2cnc(-c3ccc(C(=O)NCc4ccc(C#N)cc4)s3)c(N3CCC(N(C)C)C3)c2c1C(C)(C)C
+Cc1[nH]nc(-c2cc(C3C4CC(CCN4)N3C)nc(N3CCC4(CCCCC4)C3)n2)c1Cl
+CCN(C)c1ccc(C(=O)OCC(=O)NCC2CCCC2)cc1
+CC(C)n1cc(S(=O)(=O)NCC(=O)N2CCCC(c3ccccc3)(c3ccccc3)CC2)cn1
+S=C1NCSS1
+CC1CCC(C(=O)NC(=S)N2CCN(c3ccc([N+](=O)[O-])cc3Cl)CC2)C1
+CC(=NO)C(=O)Nc1ccc(Cl)c(C(=O)O)c1
+NCCCCCCC(=O)NC(C(=O)O)S(=O)(=O)O
+CCN1C(=O)C2CC(NC(=O)C(NC(=O)OCc3cccc([N+](=O)[O-])c3)C(C)P(=O)(O)O)CCC21
+CC(=O)C1(C)CC(c2ccc(N3CCOCC3)cc2C(F)(F)F)=NO1
+CCCCCCC(N)=O
+Nc1nc(Cl)ccc1C(c1ccc(-c2ccccn2)nc1N)N1CCCCC1
+CCC1N=C(S)NC1c1cc(F)ccc1F
+CC(=O)c1cn(C)c2ccc(S(=O)(=O)NCc3ccc(C(=O)O)cc3)cc12
+CCCCCC(=CC#N)[N+](=O)[O-]
+CN1CCCC1CCNCc1ccc(F)c(Cl)c1
+Cc1ccc(S(=O)(=O)c2nnc(-n3cc(C)sc3=O)s2)cc1
+NCC1COC(CN2CC(c3cccc([N+](=O)[O-])c3)OC2=O)C1CCC1CCCCC1
+CC(C)NC(CC(=O)Nc1cnn(C)c(=O)c1Cl)C(=O)NCc1ccc(C(F)(F)F)c(F)c1
+CC(C)CC1C(=O)N2CCCC2C(=O)N1C1(C)CCCO1
+O=C(O)c1ccc(Cn2cccc2-c2cc(NC(=O)c3cccs3)ncn2)cc1
+CCn1ncc(CC(=O)NCc2ccccc2)c1CCC(=O)NCc1ccc(F)c(F)c1
+O=C1CSC(C(=O)NCCC2CN3CCC2(c2cccc(C(F)(F)F)c2)CC3)N1
+Nc1nc(O)nc2c1CN(CCCN1C(=O)CCC1=O)CC2

app.py

@@ -0,0 +1,1084 @@
+import os
+import time
+import requests
+import numpy as np
+from flask import Flask, render_template, request, send_file
+from rdkit import Chem
+from transformers import AutoModelForMaskedLM, AutoTokenizer
+from bio_embeddings.embed import ProtTransBertBFDEmbedder
+from modelstrc import CVanilla_RNN_Builder, get_mol_from_graph_list
+
+# 🚀 Define Directories for Railway
+bio_model_dir = "/app/modelsBioembed"  # Persistent model storage
+cvn_model_dir = "/app/models_folder"
+UPLOAD_FOLDER = "/app/Samples"
+
+os.makedirs(bio_model_dir, exist_ok=True)
+os.makedirs(cvn_model_dir, exist_ok=True)
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# ✅ Environment Variables for Temp Directory
+os.environ["TMPDIR"] = bio_model_dir
+os.environ["TEMP"] = bio_model_dir
+os.environ["TMP"] = bio_model_dir
+
+# 🔗 Dropbox Links for Model Files
+DROPBOX_LINKS = {
+    "pytorch_model.bin": "https://www.dropbox.com/scl/fi/b41t8c6ji7j6uk5y2jj8g/pytorch_model.bin?rlkey=kuuwkid36ugml560c4a465ilr&st=t60bfemx&dl=1",
+    "config.json": "https://www.dropbox.com/scl/fi/js6czj3kfc4a5kshfkzie/config.json?rlkey=5oysq4ecilnan5tviuqe86v93&st=75zpce8h&dl=1",
+    "tokenizer_config.json": "https://www.dropbox.com/scl/fi/x11poym6mueoxod7xb6f1/tokenizer_config.json?rlkey=s51pik2rkmqp1fu99qj9qaria&st=z9kkcxp7&dl=1",
+    "vocab.txt": "https://www.dropbox.com/scl/fi/v6e2gn10ck4lpx4iv9kpe/vocab.txt?rlkey=dcu29g5ns4wtqdv0pkks0ehx1&st=qt187rhq&dl=1",
+    "special_tokens_map.json": "https://www.dropbox.com/scl/fi/t3lvmp5x28d1zjac3j7ec/special_tokens_map.json?rlkey=z2xbompa54iu4y9qgb5bvmfc9&st=zrxlpjdt&dl=1"
+}
+
+# 📥 Function to Download Model Files
+def download_model_files():
+    for filename, url in DROPBOX_LINKS.items():
+        file_path = os.path.join(bio_model_dir, filename)
+        if not os.path.exists(file_path):  # Avoid re-downloading
+            print(f"Downloading {filename}...")
+            response = requests.get(url, stream=True)
+            if response.status_code == 200:
+                with open(file_path, "wb") as f:
+                    for chunk in response.iter_content(chunk_size=1024):
+                        f.write(chunk)
+                print(f"Downloaded: {filename}")
+            else:
+                print(f"Failed to download {filename}")
+# def download_model_files():
+#     for filename, url in DROPBOX_LINKS.items():
+#         file_path = os.path.join(bio_model_dir, filename)
+
+#         print(f"Downloading {filename} (forcing overwrite)...")
+#         response = requests.get(url, stream=True)
+#         if response.status_code == 200:
+#             with open(file_path, "wb") as f:
+#                 for chunk in response.iter_content(chunk_size=1024):
+#                     f.write(chunk)
+#             print(f"Downloaded: {filename}")
+#         else:
+#             print(f"Failed to download {filename}")
+
+# 📥 Download models before starting
+download_model_files()
+
+# # ✅ Load ProtTrans-BERT-BFD Model
+# print("Loading ProtTrans-BERT-BFD model...")
+# model = AutoModelForMaskedLM.from_pretrained(bio_model_dir)
+# tokenizer = AutoTokenizer.from_pretrained(bio_model_dir)
+
+# ✅ Load Bio-Embedding Model
+try:
+    print("Loading ProtTrans-BERT-BFD model...")
+    embedder = ProtTransBertBFDEmbedder(model_directory=bio_model_dir)
+except Exception as e:
+    print(f"Error loading ProtTrans-BERT-BFD model: {e}")
+    embedder = None
+
+# 🧬 Generate Bio-Embeddings
+def generate_bio_embeddings(sequence):
+    if embedder is None:
+        return None
+    try:
+        embedding_protein = embedder.embed(sequence)
+        embedding_per_protein = embedder.reduce_per_protein(embedding_protein)
+        return np.array(embedding_per_protein).reshape(1, -1)
+    except Exception as e:
+        print(f"Embedding Error: {e}")
+        return None
+
+# 🔬 Generate SMILES from Protein Sequence
+def generate_smiles(sequence, n_samples=100):
+    start_time = time.time()
+
+    protein_embedding = generate_bio_embeddings(sequence)
+    if protein_embedding is None:
+        return None, "Embedding generation failed!"
+
+    model = CVanilla_RNN_Builder(cvn_model_dir, gpu_id=None)
+    samples = model.sample(n_samples, c=protein_embedding[0], output_type='graph')
+    valid_samples = [sample for sample in samples if sample is not None]
+
+    smiles_list = [
+        Chem.MolToSmiles(mol) for mol in get_mol_from_graph_list(valid_samples, sanitize=True) if mol is not None
+    ]
+
+    if not smiles_list:
+        return None, "No valid SMILES generated!"
+
+    filename = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+    with open(filename, "w") as file:
+        file.write("\n".join(smiles_list))
+
+    elapsed_time = time.time() - start_time
+    return filename, elapsed_time
+
+# 🌐 Flask Web App
+app = Flask(__name__)
+
+@app.route("/", methods=["GET", "POST"])
+def index():
+    if request.method == "POST":
+        sequence = request.form["sequence"].strip()
+        if not sequence:
+            return render_template("index.html", message="Please enter a valid sequence.")
+
+        file_path, result = generate_smiles(sequence)
+        if file_path is None:
+            return render_template("index.html", message=f"Error: {result}")
+
+        return render_template("index.html", message="SMILES generated successfully!", file_path=file_path, time_taken=result)
+
+    return render_template("index.html")
+
+@app.route("/download")
+def download_file():
+    file_path = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+    return send_file(file_path, as_attachment=True)
+
+# 🚀 Run the Flask App on Railway
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860)
+
+
+
+
+
+
+
+
+
+
+
+# import os
+# import time
+# import requests
+# import numpy as np
+# import subprocess
+# from flask import Flask, render_template, request, send_file
+# from rdkit import Chem
+# from transformers import AutoModel
+# from bio_embeddings.embed import ProtTransBertBFDEmbedder
+# from modelstrc import CVanilla_RNN_Builder, get_mol_from_graph_list
+
+# # DROPBOX LINKS FOR MODEL FILES
+# DROPBOX_LINKS = {
+#     "pytorch_model.bin": "https://www.dropbox.com/scl/fi/b41t8c6ji7j6uk5y2jj8g/pytorch_model.bin?rlkey=kuuwkid36ugml560c4a465ilr&st=t60bfemx&dl=1",
+#     "config.json": "https://www.dropbox.com/scl/fi/js6czj3kfc4a5kshfkzie/config.json?rlkey=5oysq4ecilnan5tviuqe86v93&st=75zpce8h&dl=1",
+#     "tokenizer_config.json": "https://www.dropbox.com/scl/fi/x11poym6mueoxod7xb6f1/tokenizer_config.json?rlkey=s51pik2rkmqp1fu99qj9qaria&st=z9kkcxp7&dl=1",
+#     "vocab.txt": "https://www.dropbox.com/scl/fi/v6e2gn10ck4lpx4iv9kpe/vocab.txt?rlkey=dcu29g5ns4wtqdv0pkks0ehx1&st=qt187rhq&dl=1",
+#     "special_tokens_map.json": "https://www.dropbox.com/scl/fi/t3lvmp5x28d1zjac3j7ec/special_tokens_map.json?rlkey=z2xbompa54iu4y9qgb5bvmfc9&st=zrxlpjdt&dl=1"
+# }
+
+# # LOCAL DIRECTORIES
+# bio_model_dir = os.path.join(os.getcwd(), "modelsBioembed")
+# cvn_model_dir = os.path.join(os.getcwd(), "models_folder")
+# UPLOAD_FOLDER = "Samples"
+
+# os.makedirs(bio_model_dir, exist_ok=True)
+# os.makedirs(cvn_model_dir, exist_ok=True)
+# os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# os.environ["TMPDIR"] = bio_model_dir
+# os.environ["TEMP"] = bio_model_dir
+# os.environ["TMP"] = bio_model_dir
+
+# # FUNCTION TO DOWNLOAD FILES FROM DROPBOX
+# for file_name, url in DROPBOX_LINKS.items():
+#     file_path = os.path.join(bio_model_dir, file_name)
+#     if not os.path.exists(file_path):
+#         print(f"Downloading {file_name} from Dropbox...")
+#         subprocess.run(["wget", "-O", file_path, url], check=True)
+#         print(f"{file_name} downloaded!")
+
+# # BIO-EMBEDDING MODEL LOADING
+# try:
+#     embedder = ProtTransBertBFDEmbedder(model_directory=bio_model_dir)
+# except Exception as e:
+#     print(f"Error loading ProtTrans-BERT-BFD model: {e}")
+#     embedder = None
+
+# def generate_bio_embeddings(sequence):
+#     if embedder is None:
+#         return None
+#     try:
+#         embedding_protein = embedder.embed(sequence)
+#         embedding_per_protein = embedder.reduce_per_protein(embedding_protein)
+#         return np.array(embedding_per_protein).reshape(1, -1)
+#     except Exception as e:
+#         print(f"Embedding Error: {e}")
+#         return None
+
+# def generate_smiles(sequence, n_samples=100):
+#     start_time = time.time()
+#     protein_embedding = generate_bio_embeddings(sequence)
+#     if protein_embedding is None:
+#         return None, "Embedding generation failed!"
+
+#     model = CVanilla_RNN_Builder(cvn_model_dir, gpu_id=None)
+#     samples = model.sample(n_samples, c=protein_embedding[0], output_type='graph')
+#     valid_samples = [sample for sample in samples if sample is not None]
+
+#     smiles_list = [
+#         Chem.MolToSmiles(mol) for mol in get_mol_from_graph_list(valid_samples, sanitize=True) if mol is not None
+#     ]
+
+#     if not smiles_list:
+#         return None, "No valid SMILES generated!"
+
+#     filename = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     with open(filename, "w") as file:
+#         file.write("\n".join(smiles_list))
+
+#     elapsed_time = time.time() - start_time
+#     return filename, elapsed_time
+
+# app = Flask(__name__)
+
+# @app.route("/", methods=["GET", "POST"])
+# def index():
+#     if request.method == "POST":
+#         sequence = request.form["sequence"].strip()
+#         if not sequence:
+#             return render_template("index.html", message="Please enter a valid sequence.")
+
+#         file_path, result = generate_smiles(sequence)
+#         if file_path is None:
+#             return render_template("index.html", message=f"Error: {result}")
+
+#         return render_template("index.html", message="SMILES generated successfully!", file_path=file_path, time_taken=result)
+
+#     return render_template("index.html")
+
+# @app.route("/download")
+# def download_file():
+#     file_path = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     return send_file(file_path, as_attachment=True)
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=8000, debug=True)
+
+
+
+# import os
+# import time
+# import numpy as np
+# from flask import Flask, render_template, request, send_file
+# from rdkit import Chem
+# from transformers import AutoModel
+# from bio_embeddings.embed import ProtTransBertBFDEmbedder
+# from modelstrc import CVanilla_RNN_Builder, get_mol_from_graph_list
+
+# # # DIRECTORIES
+# # bio_model_dir = os.path.join(os.getcwd(), "modelsBioembed")  # For bio-embeddings
+# # cvn_model_dir = os.path.join(os.getcwd(), "models_folder")  # For CVanilla_RNN_Builder
+# #bio_model_dir = os.getenv("BIO_MODEL_DIR", "modelsBioembed")
+# bio_model_dir = "/app/modelsBioembed"
+# cvn_model_dir = os.getenv("CVN_MODEL_DIR", "models_folder")
+
+
+# os.makedirs(bio_model_dir, exist_ok=True)
+# os.makedirs(cvn_model_dir, exist_ok=True)
+
+# os.environ["TMPDIR"] = bio_model_dir
+# os.environ["TEMP"] = bio_model_dir
+# os.environ["TMP"] = bio_model_dir
+
+# UPLOAD_FOLDER = "Samples"
+# os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# app = Flask(__name__)
+
+# # model_path = os.path.join(bio_model_dir, "pytorch_model.bin")
+# # if not os.path.exists(model_path):
+# #     print("Downloading ProtTrans-BERT-BFD model...")
+# #     AutoModel.from_pretrained("Rostlab/prot_bert_bfd", low_cpu_mem_usage=True).save_pretrained(bio_model_dir)
+
+
+# # BIO-EMBEDDING MODEL LOADING
+# try:
+#     print("Loading Model")
+#     embedder = ProtTransBertBFDEmbedder(model_directory=bio_model_dir)
+# except Exception as e:
+#     print(f"Error loading ProtTrans-BERT-BFD model: {e}")
+#     embedder = None
+
+# def generate_bio_embeddings(sequence):
+#     """Generate bio-embeddings for a given protein sequence."""
+#     if embedder is None:
+#         return None
+#     try:
+#         embedding_protein = embedder.embed(sequence)
+#         embedding_per_protein = embedder.reduce_per_protein(embedding_protein)
+#         return np.array(embedding_per_protein).reshape(1, -1)  # Reshape for model compatibility
+#     except Exception as e:
+#         print(f"Embedding Error: {e}")
+#         return None
+
+# def generate_smiles(sequence, n_samples=100):
+#     """Generate SMILES from a protein sequence."""
+#     start_time = time.time()
+
+#     protein_embedding = generate_bio_embeddings(sequence)
+#     if protein_embedding is None:
+#         return None, "Embedding generation failed!"
+
+#     # TRAINED CVanilla_RNN_Builder MODEL LOADING
+#     model = CVanilla_RNN_Builder(cvn_model_dir, gpu_id=None)
+
+#     # MOLECULAR GRAPH GENERATION
+#     samples = model.sample(n_samples, c=protein_embedding[0], output_type='graph')
+#     valid_samples = [sample for sample in samples if sample is not None]
+
+#     # CONVERSION TO SMILES
+#     smiles_list = [
+#         Chem.MolToSmiles(mol) for mol in get_mol_from_graph_list(valid_samples, sanitize=True) if mol is not None
+#     ]
+
+#     if not smiles_list:
+#         return None, "No valid SMILES generated!"
+
+#     # SAVING TO FILE
+#     filename = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     with open(filename, "w") as file:
+#         file.write("\n".join(smiles_list))
+
+#     elapsed_time = time.time() - start_time
+#     return filename, elapsed_time
+
+# @app.route("/", methods=["GET", "POST"])
+# def index():
+#     if request.method == "POST":
+#         sequence = request.form["sequence"].strip()
+#         if not sequence:
+#             return render_template("index.html", message="Please enter a valid sequence.")
+
+#         file_path, result = generate_smiles(sequence)
+#         if file_path is None:
+#             return render_template("index.html", message=f"Error: {result}")
+
+#         return render_template("index.html", message="SMILES generated successfully!", file_path=file_path, time_taken=result)
+
+#     return render_template("index.html")
+
+# @app.route("/download")
+# def download_file():
+#     file_path = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     return send_file(file_path, as_attachment=True)
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=8000)
+#MAIN
+
+
+
+
+# import os
+# import time
+# import requests
+# import numpy as np
+# from flask import Flask, render_template, request, send_file
+# from rdkit import Chem
+# from transformers import AutoModel
+# from bio_embeddings.embed import ProtTransBertBFDEmbedder
+# from modelstrc import CVanilla_RNN_Builder, get_mol_from_graph_list
+
+# # HUGGING FACE MODEL REPO (Replace with your actual Hugging Face username)
+# MODEL_BASE_URL = "https://huggingface.co/Bhanushray/protein-smiles-model/tree/main"
+
+# # REQUIRED MODEL FILES
+# MODEL_FILES = [
+#     "pytorch_model.bin",
+#     "config.json",
+#     "tokenizer_config.json",
+#     "vocab.txt",
+#     "special_tokens_map.json"
+# ]
+
+# #  DIRECTORIES
+# bio_model_dir = os.getenv("BIO_MODEL_DIR", "modelsBioembed")
+# cvn_model_dir = os.getenv("CVN_MODEL_DIR", "models_folder")
+
+# # bio_model_dir = os.path.join(os.getcwd(), "modelsBioembed")  # For bio-embeddings
+# # cvn_model_dir = os.path.join(os.getcwd(), "models_folder")  # For CVanilla_RNN_Builder
+
+# os.makedirs(bio_model_dir, exist_ok=True)
+# os.makedirs(cvn_model_dir, exist_ok=True)
+
+# os.environ["TMPDIR"] = bio_model_dir
+# os.environ["TEMP"] = bio_model_dir
+# os.environ["TMP"] = bio_model_dir
+
+# UPLOAD_FOLDER = "Samples"
+# os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# app = Flask(__name__)
+
+# #  DOWNLOAD MODEL FILES IF MISSING
+# for file_name in MODEL_FILES:
+#     file_path = os.path.join(bio_model_dir, file_name)
+    
+#     if not os.path.exists(file_path):
+#         print(f"Downloading {file_name} ...")
+#         response = requests.get(MODEL_BASE_URL + file_name, stream=True)
+#         with open(file_path, "wb") as f:
+#             for chunk in response.iter_content(chunk_size=1024):
+#                 f.write(chunk)
+#         print(f"{file_name} downloaded!")
+
+# # BIO-EMBEDDING MODEL LOADING
+# try:
+#     embedder = ProtTransBertBFDEmbedder(model_directory=bio_model_dir)
+# except Exception as e:
+#     print(f"Error loading ProtTrans-BERT-BFD model: {e}")
+#     embedder = None
+
+# def generate_bio_embeddings(sequence):
+#     """Generate bio-embeddings for a given protein sequence."""
+#     if embedder is None:
+#         return None
+#     try:
+#         embedding_protein = embedder.embed(sequence)
+#         embedding_per_protein = embedder.reduce_per_protein(embedding_protein)
+#         return np.array(embedding_per_protein).reshape(1, -1)  # Reshape for model compatibility
+#     except Exception as e:
+#         print(f"Embedding Error: {e}")
+#         return None
+
+# def generate_smiles(sequence, n_samples=100):
+#     """Generate SMILES from a protein sequence."""
+#     start_time = time.time()
+
+#     protein_embedding = generate_bio_embeddings(sequence)
+#     if protein_embedding is None:
+#         return None, "Embedding generation failed!"
+
+#     # LOAD TRAINED CVanilla_RNN_Builder MODEL
+#     model = CVanilla_RNN_Builder(cvn_model_dir, gpu_id=None)
+
+#     # MOLECULAR GRAPH GENERATION
+#     samples = model.sample(n_samples, c=protein_embedding[0], output_type='graph')
+#     valid_samples = [sample for sample in samples if sample is not None]
+
+#     #  CONVERT TO SMILES
+#     smiles_list = [
+#         Chem.MolToSmiles(mol) for mol in get_mol_from_graph_list(valid_samples, sanitize=True) if mol is not None
+#     ]
+
+#     if not smiles_list:
+#         return None, "No valid SMILES generated!"
+
+#     # SAVE TO FILE
+#     filename = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     with open(filename, "w") as file:
+#         file.write("\n".join(smiles_list))
+
+#     elapsed_time = time.time() - start_time
+#     return filename, elapsed_time
+
+# @app.route("/", methods=["GET", "POST"])
+# def index():
+#     if request.method == "POST":
+#         sequence = request.form["sequence"].strip()
+#         if not sequence:
+#             return render_template("index.html", message="Please enter a valid sequence.")
+
+#         file_path, result = generate_smiles(sequence)
+#         if file_path is None:
+#             return render_template("index.html", message=f"Error: {result}")
+
+#         return render_template("index.html", message="SMILES generated successfully!", file_path=file_path, time_taken=result)
+
+#     return render_template("index.html")
+
+# @app.route("/download")
+# def download_file():
+#     file_path = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     return send_file(file_path, as_attachment=True)
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=8000, debug=True)
+
+
+# import os
+# import time
+# import numpy as np
+# from flask import Flask, render_template, request, send_file
+# from rdkit import Chem
+# from transformers import AutoModel
+# from bio_embeddings.embed import ProtTransBertBFDEmbedder
+# from modelstrc import CVanilla_RNN_Builder, get_mol_from_graph_list
+
+# # DIRECTORIES
+# bio_model_dir = os.path.join(os.getcwd(), "modelsBioembed")  # For bio-embeddings
+# cvn_model_dir = os.path.join(os.getcwd(), "models_folder")  # For CVanilla_RNN_Builder
+
+# os.makedirs(bio_model_dir, exist_ok=True)
+# os.makedirs(cvn_model_dir, exist_ok=True)
+
+# os.environ["TMPDIR"] = bio_model_dir
+# os.environ["TEMP"] = bio_model_dir
+# os.environ["TMP"] = bio_model_dir
+
+# UPLOAD_FOLDER = "Samples"
+# os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# app = Flask(__name__)
+
+# model_path = os.path.join(bio_model_dir, "pytorch_model.bin")
+# if not os.path.exists(model_path):
+#     print("Downloading ProtTrans-BERT-BFD model...")
+#     AutoModel.from_pretrained("Rostlab/prot_bert_bfd", low_cpu_mem_usage=True).save_pretrained(bio_model_dir)
+
+
+# # BIO-EMBEDDING MODEL LOADING
+# try:
+#     embedder = ProtTransBertBFDEmbedder(model_directory=bio_model_dir)
+# except Exception as e:
+#     print(f"Error loading ProtTrans-BERT-BFD model: {e}")
+#     embedder = None
+
+# def generate_bio_embeddings(sequence):
+#     """Generate bio-embeddings for a given protein sequence."""
+#     if embedder is None:
+#         return None
+#     try:
+#         embedding_protein = embedder.embed(sequence)
+#         embedding_per_protein = embedder.reduce_per_protein(embedding_protein)
+#         return np.array(embedding_per_protein).reshape(1, -1)  # Reshape for model compatibility
+#     except Exception as e:
+#         print(f"Embedding Error: {e}")
+#         return None
+
+# def generate_smiles(sequence, n_samples=100):
+#     """Generate SMILES from a protein sequence."""
+#     start_time = time.time()
+
+#     protein_embedding = generate_bio_embeddings(sequence)
+#     if protein_embedding is None:
+#         return None, "Embedding generation failed!"
+
+#     # TRAINED CVanilla_RNN_Builder MODEL LOADING
+#     model = CVanilla_RNN_Builder(cvn_model_dir, gpu_id=None)
+
+#     # MOLECULAR GRAPH GENERATION
+#     samples = model.sample(n_samples, c=protein_embedding[0], output_type='graph')
+#     valid_samples = [sample for sample in samples if sample is not None]
+
+#     # CONVERSION TO SMILES
+#     smiles_list = [
+#         Chem.MolToSmiles(mol) for mol in get_mol_from_graph_list(valid_samples, sanitize=True) if mol is not None
+#     ]
+
+#     if not smiles_list:
+#         return None, "No valid SMILES generated!"
+
+#     # SAVING TO FILE
+#     filename = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     with open(filename, "w") as file:
+#         file.write("\n".join(smiles_list))
+
+#     elapsed_time = time.time() - start_time
+#     return filename, elapsed_time
+
+# @app.route("/", methods=["GET", "POST"])
+# def index():
+#     if request.method == "POST":
+#         sequence = request.form["sequence"].strip()
+#         if not sequence:
+#             return render_template("index.html", message="Please enter a valid sequence.")
+
+#         file_path, result = generate_smiles(sequence)
+#         if file_path is None:
+#             return render_template("index.html", message=f"Error: {result}")
+
+#         return render_template("index.html", message="SMILES generated successfully!", file_path=file_path, time_taken=result)
+
+#     return render_template("index.html")
+
+# @app.route("/download")
+# def download_file():
+#     file_path = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     return send_file(file_path, as_attachment=True)
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=8000,debug=True)
+
+
+
+
+
+
+
+
+
+
+
+
+
+# import os
+# import time
+# import numpy as np
+# from flask import Flask, render_template, request, send_file
+# from rdkit import Chem
+# from transformers import AutoModel
+# from bio_embeddings.embed import ProtTransBertBFDEmbedder
+# from modelstrc import CVanilla_RNN_Builder, get_mol_from_graph_list
+# from huggingface_hub import hf_hub_download  # Import for direct file download
+
+# # Define directories for different models
+# bio_model_dir = os.path.join(os.getcwd(), "modelsBioembed")  # For bio-embeddings
+# cvn_model_dir = os.path.join(os.getcwd(), "models_folder")  # For CVanilla_RNN_Builder
+
+# # Ensure directories exist
+# os.makedirs(bio_model_dir, exist_ok=True)
+# os.makedirs(cvn_model_dir, exist_ok=True)
+
+# UPLOAD_FOLDER = "Samples"
+# os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# app = Flask(__name__)
+
+# # Download only the required pytorch_model.bin file
+# model_filename = "pytorch_model.bin"
+# model_path = os.path.join(bio_model_dir, model_filename)
+# if not os.path.exists(model_path):
+#     print("Downloading pytorch_model.bin from Hugging Face...")
+#     hf_hub_download(repo_id="Rostlab/prot_bert_bfd", filename=model_filename, local_dir=bio_model_dir)
+
+# # Load bio-embedding model once
+# embedder = ProtTransBertBFDEmbedder(model_directory=bio_model_dir)
+
+# def generate_bio_embeddings(sequence):
+#     """Generate bio-embeddings for a given protein sequence."""
+#     try:
+#         embedding_protein = embedder.embed(sequence)
+#         embedding_per_protein = embedder.reduce_per_protein(embedding_protein)
+#         return np.array(embedding_per_protein).reshape(1, -1)
+#     except Exception as e:
+#         print(f"Embedding Error: {e}")
+#         return None
+
+# def generate_smiles(sequence, n_samples=100):
+#     """Generate SMILES from a protein sequence."""
+#     start_time = time.time()
+
+#     protein_embedding = generate_bio_embeddings(sequence)
+#     if protein_embedding is None:
+#         return None, "Embedding generation failed!"
+
+#     model = CVanilla_RNN_Builder(cvn_model_dir, gpu_id=None)
+#     samples = model.sample(n_samples, c=protein_embedding[0], output_type='graph')
+#     valid_samples = [sample for sample in samples if sample is not None]
+
+#     smiles_list = [
+#         Chem.MolToSmiles(mol) for mol in get_mol_from_graph_list(valid_samples, sanitize=True) if mol is not None
+#     ]
+
+#     if not smiles_list:
+#         return None, "No valid SMILES generated!"
+
+#     filename = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     with open(filename, "w") as file:
+#         file.write("\n".join(smiles_list))
+
+#     elapsed_time = time.time() - start_time
+#     return filename, elapsed_time
+
+# @app.route("/", methods=["GET", "POST"])
+# def index():
+#     if request.method == "POST":
+#         sequence = request.form["sequence"].strip()
+#         if not sequence:
+#             return render_template("index.html", message="Please enter a valid sequence.")
+
+#         file_path, result = generate_smiles(sequence)
+#         if file_path is None:
+#             return render_template("index.html", message=f"Error: {result}")
+
+#         return render_template("index.html", message="SMILES generated successfully!", file_path=file_path, time_taken=result)
+
+#     return render_template("index.html")
+
+# @app.route("/download")
+# def download_file():
+#     file_path = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     return send_file(file_path, as_attachment=True)
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=8000, debug=True)
+
+
+
+
+
+# import os
+# import time
+# import requests
+# import numpy as np
+# import gdown  # NEW: For Google Drive downloads
+# from flask import Flask, render_template, request, send_file
+# from rdkit import Chem
+# from transformers import AutoModel
+# from bio_embeddings.embed import ProtTransBertBFDEmbedder
+# from modelstrc import CVanilla_RNN_Builder, get_mol_from_graph_list
+
+# # REPLACE WITH YOUR GOOGLE DRIVE FILE IDs
+# GDRIVE_FILE_IDS = {
+#     "pytorch_model.bin": "11g7bAXYNxlPsnwC8_qsUIZITAjG85JXb",  # Replace with actual ID
+#     "config.json": "1ZfuhTnEuKAI1Z92m1QnDTOEQYNe9y24E",
+#     "tokenizer_config.json": "1r4ncUsWBNQZVKp4zw97DLTf0AgRUiuFc",
+#     "vocab.txt": "1G1UQIGMHvCC3OokCG1tl-cTxjIVqw04w",
+#     "special_tokens_map.json": "1pINnV2P1eBmaC7X0A52UhjrmlJgzxqbl"
+# }
+
+# # LOCAL DIRECTORIES
+# bio_model_dir = os.path.join(os.getcwd(), "modelsBioembed")  # For bio-embeddings
+# cvn_model_dir = os.path.join(os.getcwd(), "models_folder")  # For CVanilla_RNN_Builder
+
+# os.makedirs(bio_model_dir, exist_ok=True)
+# os.makedirs(cvn_model_dir, exist_ok=True)
+
+# os.environ["TMPDIR"] = bio_model_dir
+# os.environ["TEMP"] = bio_model_dir
+# os.environ["TMP"] = bio_model_dir
+
+# UPLOAD_FOLDER = "Samples"
+# os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+
+# app = Flask(__name__)
+
+# # DOWNLOAD MODEL FILES IF MISSING
+# for file_name, file_id in GDRIVE_FILE_IDS.items():
+#     file_path = os.path.join(bio_model_dir, file_name)
+    
+#     if not os.path.exists(file_path):
+#         print(f"Downloading {file_name} from Google Drive...")
+#         gdown.download(f"https://drive.google.com/uc?id={file_id}", file_path, quiet=False)
+#         print(f"{file_name} downloaded!")
+
+# # BIO-EMBEDDING MODEL LOADING
+# try:
+#     embedder = ProtTransBertBFDEmbedder(model_directory=bio_model_dir)
+# except Exception as e:
+#     print(f"Error loading ProtTrans-BERT-BFD model: {e}")
+#     embedder = None
+
+# def generate_bio_embeddings(sequence):
+#     """Generate bio-embeddings for a given protein sequence."""
+#     if embedder is None:
+#         return None
+#     try:
+#         embedding_protein = embedder.embed(sequence)
+#         embedding_per_protein = embedder.reduce_per_protein(embedding_protein)
+#         return np.array(embedding_per_protein).reshape(1, -1)  # Reshape for model compatibility
+#     except Exception as e:
+#         print(f"Embedding Error: {e}")
+#         return None
+
+# def generate_smiles(sequence, n_samples=100):
+#     """Generate SMILES from a protein sequence."""
+#     start_time = time.time()
+
+#     protein_embedding = generate_bio_embeddings(sequence)
+#     if protein_embedding is None:
+#         return None, "Embedding generation failed!"
+
+#     # LOAD TRAINED CVanilla_RNN_Builder MODEL
+#     model = CVanilla_RNN_Builder(cvn_model_dir, gpu_id=None)
+
+#     # MOLECULAR GRAPH GENERATION
+#     samples = model.sample(n_samples, c=protein_embedding[0], output_type='graph')
+#     valid_samples = [sample for sample in samples if sample is not None]
+
+#     # CONVERT TO SMILES
+#     smiles_list = [
+#         Chem.MolToSmiles(mol) for mol in get_mol_from_graph_list(valid_samples, sanitize=True) if mol is not None
+#     ]
+
+#     if not smiles_list:
+#         return None, "No valid SMILES generated!"
+
+#     # SAVE TO FILE
+#     filename = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     with open(filename, "w") as file:
+#         file.write("\n".join(smiles_list))
+
+#     elapsed_time = time.time() - start_time
+#     return filename, elapsed_time
+
+# @app.route("/", methods=["GET", "POST"])
+# def index():
+#     if request.method == "POST":
+#         sequence = request.form["sequence"].strip()
+#         if not sequence:
+#             return render_template("index.html", message="Please enter a valid sequence.")
+
+#         file_path, result = generate_smiles(sequence)
+#         if file_path is None:
+#             return render_template("index.html", message=f"Error: {result}")
+
+#         return render_template("index.html", message="SMILES generated successfully!", file_path=file_path, time_taken=result)
+
+#     return render_template("index.html")
+
+# @app.route("/download")
+# def download_file():
+#     file_path = os.path.join(UPLOAD_FOLDER, "SMILES_GENERATED.txt")
+#     return send_file(file_path, as_attachment=True)
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=8000, debug=True)
+
+
+
+# import os
+# import time
+# import gdown
+# import numpy as np
+# from flask import Flask, render_template, request, send_file
+# from rdkit import Chem
+# from bio_embeddings.embed import ProtTransBertBFDEmbedder
+# from modelstrc import CVanilla_RNN_Builder, get_mol_from_graph_list
+
+# # DIRECTORIES
+# bio_model_dir = "/app/modelsBioembed"
+# cvn_model_dir = os.getenv("CVN_MODEL_DIR", "models_folder")
+# upload_folder = "Samples"
+
+# # Create directories if they don't exist
+# os.makedirs(bio_model_dir, exist_ok=True)
+# os.makedirs(cvn_model_dir, exist_ok=True)
+# os.makedirs(upload_folder, exist_ok=True)
+
+# # Google Drive file IDs for the model files
+# MODEL_FILES = {
+#     "pytorch_model.bin": "1Z9XWk-kP5yrBRdBF_mQPQsM8drqQXafJ",
+#     "config.json": "1adE428T5ZWeosoLsBeX7sVnn6m4VvVgL",
+#     "tokenizer_config.json": "1USvLAZ3dM4TzVSRLjINk2_W989k1HDQ0",
+#     "vocab.txt": "1tsdesfbr61UyLShV0ojvsXOp6VJ9Exrt",
+#     "special_tokens_map.json": "1ChCwdz0NH8ODasqscGwCS9mY7urhQte2",
+# }
+
+# # Function to download missing files from Google Drive
+# def download_model_files():
+#     for filename, file_id in MODEL_FILES.items():
+#         file_path = os.path.join(bio_model_dir, filename)
+#         if not os.path.exists(file_path):
+#             print(f"Downloading {filename} from Google Drive...")
+#             gdown.download(f"https://drive.google.com/uc?id={file_id}", file_path, quiet=False)
+
+# # Download required model files
+# download_model_files()
+# print("All model files are ready!")
+
+# # Load the ProtTrans-BERT-BFD Model
+# try:
+#     embedder = ProtTransBertBFDEmbedder(model_directory=bio_model_dir)
+#     print("ProtTrans-BERT-BFD model loaded successfully!")
+# except Exception as e:
+#     print(f"Error loading model: {e}")
+#     embedder = None
+
+# # Function to generate protein embeddings
+# def generate_bio_embeddings(sequence):
+#     if embedder is None:
+#         return None
+#     try:
+#         embedding_protein = embedder.embed(sequence)
+#         embedding_per_protein = embedder.reduce_per_protein(embedding_protein)
+#         return np.array(embedding_per_protein).reshape(1, -1)
+#     except Exception as e:
+#         print(f"Embedding Error: {e}")
+#         return None
+
+# # Function to generate SMILES from a protein sequence
+# def generate_smiles(sequence, n_samples=100):
+#     start_time = time.time()
+
+#     protein_embedding = generate_bio_embeddings(sequence)
+#     if protein_embedding is None:
+#         return None, "Embedding generation failed!"
+
+#     # Load the trained CVanilla_RNN_Builder model
+#     model = CVanilla_RNN_Builder(cvn_model_dir, gpu_id=None)
+
+#     # Generate molecular graphs
+#     samples = model.sample(n_samples, c=protein_embedding[0], output_type='graph')
+#     valid_samples = [sample for sample in samples if sample is not None]
+
+#     # Convert to SMILES format
+#     smiles_list = [
+#         Chem.MolToSmiles(mol) for mol in get_mol_from_graph_list(valid_samples, sanitize=True) if mol is not None
+#     ]
+
+#     if not smiles_list:
+#         return None, "No valid SMILES generated!"
+
+#     # Save SMILES to a file
+#     filename = os.path.join(upload_folder, "SMILES_GENERATED.txt")
+#     with open(filename, "w") as file:
+#         file.write("\n".join(smiles_list))
+
+#     elapsed_time = time.time() - start_time
+#     return filename, elapsed_time
+
+# # Initialize Flask App
+# app = Flask(__name__)
+
+# @app.route("/", methods=["GET", "POST"])
+# def index():
+#     if request.method == "POST":
+#         sequence = request.form["sequence"].strip()
+#         if not sequence:
+#             return render_template("index.html", message="Please enter a valid sequence.")
+
+#         file_path, result = generate_smiles(sequence)
+#         if file_path is None:
+#             return render_template("index.html", message=f"Error: {result}")
+
+#         return render_template("index.html", message="SMILES generated successfully!", file_path=file_path, time_taken=result)
+
+#     return render_template("index.html")
+
+# @app.route("/download")
+# def download_file():
+#     file_path = os.path.join(upload_folder, "SMILES_GENERATED.txt")
+#     return send_file(file_path, as_attachment=True)
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=8000)
+
+
+
+# import os
+# import time
+# import requests
+# from flask import Flask, render_template, request, send_file
+# from rdkit import Chem
+# from bio_embeddings.embed import ProtTransBertBFDEmbedder
+# from modelstrc import CVanilla_RNN_Builder, get_mol_from_graph_list
+
+# # DIRECTORIES
+# bio_model_dir = "/app/modelsBioembed"
+# cvn_model_dir = os.getenv("CVN_MODEL_DIR", "models_folder")
+# upload_folder = "Samples"
+
+# # Create directories if they don't exist
+# os.makedirs(bio_model_dir, exist_ok=True)
+# os.makedirs(cvn_model_dir, exist_ok=True)
+# os.makedirs(upload_folder, exist_ok=True)
+
+# # Google Drive file IDs for the model files
+# MODEL_FILES = {
+#     "pytorch_model.bin": "1Z9XWk-kP5yrBRdBF_mQPQsM8drqQXafJ",
+#     "config.json": "1adE428T5ZWeosoLsBeX7sVnn6m4VvVgL",
+#     "tokenizer_config.json": "1USvLAZ3dM4TzVSRLjINk2_W989k1HDQ0",
+#     "vocab.txt": "1tsdesfbr61UyLShV0ojvsXOp6VJ9Exrt",
+#     "special_tokens_map.json": "1ChCwdz0NH8ODasqscGwCS9mY7urhQte2",
+# }
+
+# # Function to download a file from Google Drive
+# def download_file_from_google_drive(file_id, destination):
+#     URL = f"https://drive.google.com/uc?export=download&id={file_id}"
+#     session = requests.Session()
+#     response = session.get(URL, stream=True)
+    
+#     # Check if the request was successful
+#     if response.status_code == 200:
+#         with open(destination, "wb") as f:
+#             for chunk in response.iter_content(chunk_size=128):
+#                 f.write(chunk)
+#         print(f"Downloaded {destination}")
+#     else:
+#         print(f"Failed to download {destination}")
+
+# # Function to download missing files from Google Drive
+# def download_model_files():
+#     for filename, file_id in MODEL_FILES.items():
+#         file_path = os.path.join(bio_model_dir, filename)
+#         if not os.path.exists(file_path):
+#             print(f"Downloading {filename} from Google Drive...")
+#             download_file_from_google_drive(file_id, file_path)
+
+# # Download required model files
+# download_model_files()
+# print("All model files are ready!")
+
+# # Load the ProtTrans-BERT-BFD Model
+# try:
+#     embedder = ProtTransBertBFDEmbedder(model_directory=bio_model_dir)
+#     print("ProtTrans-BERT-BFD model loaded successfully!")
+# except Exception as e:
+#     print(f"Error loading model: {e}")
+#     embedder = None
+
+# # Function to generate protein embeddings
+# def generate_bio_embeddings(sequence):
+#     if embedder is None:
+#         return None
+#     try:
+#         embedding_protein = embedder.embed(sequence)
+#         embedding_per_protein = embedder.reduce_per_protein(embedding_protein)
+#         return np.array(embedding_per_protein).reshape(1, -1)
+#     except Exception as e:
+#         print(f"Embedding Error: {e}")
+#         return None
+
+# # Function to generate SMILES from a protein sequence
+# def generate_smiles(sequence, n_samples=100):
+#     start_time = time.time()
+
+#     protein_embedding = generate_bio_embeddings(sequence)
+#     if protein_embedding is None:
+#         return None, "Embedding generation failed!"
+
+#     # Load the trained CVanilla_RNN_Builder model
+#     model = CVanilla_RNN_Builder(cvn_model_dir, gpu_id=None)
+
+#     # Generate molecular graphs
+#     samples = model.sample(n_samples, c=protein_embedding[0], output_type='graph')
+#     valid_samples = [sample for sample in samples if sample is not None]
+
+#     # Convert to SMILES format
+#     smiles_list = [
+#         Chem.MolToSmiles(mol) for mol in get_mol_from_graph_list(valid_samples, sanitize=True) if mol is not None
+#     ]
+
+#     if not smiles_list:
+#         return None, "No valid SMILES generated!"
+
+#     # Save SMILES to a file
+#     filename = os.path.join(upload_folder, "SMILES_GENERATED.txt")
+#     with open(filename, "w") as file:
+#         file.write("\n".join(smiles_list))
+
+#     elapsed_time = time.time() - start_time
+#     return filename, elapsed_time
+
+# # Initialize Flask App
+# app = Flask(__name__)
+
+# @app.route("/", methods=["GET", "POST"])
+# def index():
+#     if request.method == "POST":
+#         sequence = request.form["sequence"].strip()
+#         if not sequence:
+#             return render_template("index.html", message="Please enter a valid sequence.")
+
+#         file_path, result = generate_smiles(sequence)
+#         if file_path is None:
+#             return render_template("index.html", message=f"Error: {result}")
+
+#         return render_template("index.html", message="SMILES generated successfully!", file_path=file_path, time_taken=result)
+
+#     return render_template("index.html")
+
+# @app.route("/download")
+# def download_file():
+#     file_path = os.path.join(upload_folder, "SMILES_GENERATED.txt")
+#     return send_file(file_path, as_attachment=True)
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=8000)
+

modelsBioembed/.gitattributes

@@ -0,0 +1,8 @@
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text

modelsBioembed/README.md

@@ -0,0 +1,141 @@
+---
+language: protein
+tags:
+- protein language model
+datasets:
+- BFD
+---
+
+# ProtBert-BFD model
+
+Pretrained model on protein sequences using a masked language modeling (MLM) objective. It was introduced in
+[this paper](https://doi.org/10.1101/2020.07.12.199554) and first released in
+[this repository](https://github.com/agemagician/ProtTrans). This model is trained on uppercase amino acids: it only works with capital letter amino acids.
+
+
+## Model description
+
+ProtBert-BFD is based on Bert model which pretrained on a large corpus of protein sequences in a self-supervised fashion.
+This means it was pretrained on the raw protein sequences only, with no humans labelling them in any way (which is why it can use lots of
+publicly available data) with an automatic process to generate inputs and labels from those protein sequences.
+
+One important difference between our Bert model and the original Bert version is the way of dealing with sequences as separate documents
+This means the Next sentence prediction is not used, as each sequence is treated as a complete document.
+The masking follows the original Bert training with randomly masks 15% of the amino acids in the input. 
+
+At the end, the feature extracted from this model revealed that the LM-embeddings from unlabeled data (only protein sequences) captured important biophysical properties governing protein
+shape.
+This implied learning some of the grammar of the language of life realized in protein sequences.
+
+## Intended uses & limitations
+
+The model could be used for protein feature extraction or to be fine-tuned on downstream tasks.
+We have noticed in some tasks you could gain more accuracy by fine-tuning the model rather than using it as a feature extractor.
+
+### How to use
+
+You can use this model directly with a pipeline for masked language modeling:
+
+```python
+>>> from transformers import BertForMaskedLM, BertTokenizer, pipeline
+>>> tokenizer = BertTokenizer.from_pretrained('Rostlab/prot_bert_bfd', do_lower_case=False )
+>>> model = BertForMaskedLM.from_pretrained("Rostlab/prot_bert_bfd")
+>>> unmasker = pipeline('fill-mask', model=model, tokenizer=tokenizer)
+>>> unmasker('D L I P T S S K L V V [MASK] D T S L Q V K K A F F A L V T')
+
+[{'score': 0.1165614128112793,
+  'sequence': '[CLS] D L I P T S S K L V V L D T S L Q V K K A F F A L V T [SEP]',
+  'token': 5,
+  'token_str': 'L'},
+ {'score': 0.08976086974143982,
+  'sequence': '[CLS] D L I P T S S K L V V V D T S L Q V K K A F F A L V T [SEP]',
+  'token': 8,
+  'token_str': 'V'},
+ {'score': 0.08864385634660721,
+  'sequence': '[CLS] D L I P T S S K L V V S D T S L Q V K K A F F A L V T [SEP]',
+  'token': 10,
+  'token_str': 'S'},
+ {'score': 0.06227643042802811,
+  'sequence': '[CLS] D L I P T S S K L V V A D T S L Q V K K A F F A L V T [SEP]',
+  'token': 6,
+  'token_str': 'A'},
+ {'score': 0.06194969266653061,
+  'sequence': '[CLS] D L I P T S S K L V V T D T S L Q V K K A F F A L V T [SEP]',
+  'token': 15,
+  'token_str': 'T'}]
+```
+
+Here is how to use this model to get the features of a given protein sequence in PyTorch:
+
+```python
+from transformers import BertModel, BertTokenizer
+import re
+tokenizer = BertTokenizer.from_pretrained('Rostlab/prot_bert_bfd', do_lower_case=False )
+model = BertModel.from_pretrained("Rostlab/prot_bert_bfd")
+sequence_Example = "A E T C Z A O"
+sequence_Example = re.sub(r"[UZOB]", "X", sequence_Example)
+encoded_input = tokenizer(sequence_Example, return_tensors='pt')
+output = model(**encoded_input)
+```
+
+## Training data
+
+The ProtBert-BFD model was pretrained on [BFD](https://bfd.mmseqs.com/), a dataset consisting of 2.1 billion protein sequences.
+
+## Training procedure
+
+### Preprocessing
+
+The protein sequences are uppercased and tokenized using a single space and a vocabulary size of 21.
+The inputs of the model are then of the form:
+
+```
+[CLS] Protein Sequence A [SEP] Protein Sequence B [SEP]
+```
+
+Furthermore, each protein sequence was treated as a separate document.
+The preprocessing step was performed twice, once for a combined length (2 sequences) of less than 512 amino acids, and another time using a combined length (2 sequences) of less than 2048 amino acids.
+
+The details of the masking procedure for each sequence followed the original Bert model as following:
+- 15% of the amino acids are masked.
+- In 80% of the cases, the masked amino acids are replaced by `[MASK]`.
+- In 10% of the cases, the masked amino acids are replaced by a random amino acid (different) from the one they replace.
+- In the 10% remaining cases, the masked amino acids are left as is.
+
+### Pretraining
+
+The model was trained on a single TPU Pod V3-1024 for one million steps in total.
+800k steps using sequence length 512 (batch size 32k), and 200K steps using sequence length 2048 (batch size 6k).
+The optimizer used is Lamb with a learning rate of 0.002, a weight decay of 0.01, learning rate warmup for 140k steps and linear decay of the learning rate after.
+
+## Evaluation results
+
+When fine-tuned on downstream tasks, this model achieves the following results:
+
+Test results :
+
+| Task/Dataset | secondary structure (3-states) | secondary structure (8-states)  |  Localization | Membrane  |
+|:-----:|:-----:|:-----:|:-----:|:-----:|
+|   CASP12  | 76 | 65 |    |    |
+|   TS115   | 84 | 73 |    |    | 
+|   CB513   | 83 | 70 |    |    |
+|  DeepLoc  |    |    | 78 | 91 |
+
+### BibTeX entry and citation info
+
+```bibtex
+@article {Elnaggar2020.07.12.199554,
+	author = {Elnaggar, Ahmed and Heinzinger, Michael and Dallago, Christian and Rehawi, Ghalia and Wang, Yu and Jones, Llion and Gibbs, Tom and Feher, Tamas and Angerer, Christoph and Steinegger, Martin and BHOWMIK, DEBSINDHU and Rost, Burkhard},
+	title = {ProtTrans: Towards Cracking the Language of Life{\textquoteright}s Code Through Self-Supervised Deep Learning and High Performance Computing},
+	elocation-id = {2020.07.12.199554},
+	year = {2020},
+	doi = {10.1101/2020.07.12.199554},
+	publisher = {Cold Spring Harbor Laboratory},
+	abstract = {Computational biology and bioinformatics provide vast data gold-mines from protein sequences, ideal for Language Models (LMs) taken from Natural Language Processing (NLP). These LMs reach for new prediction frontiers at low inference costs. Here, we trained two auto-regressive language models (Transformer-XL, XLNet) and two auto-encoder models (Bert, Albert) on data from UniRef and BFD containing up to 393 billion amino acids (words) from 2.1 billion protein sequences (22- and 112 times the entire English Wikipedia). The LMs were trained on the Summit supercomputer at Oak Ridge National Laboratory (ORNL), using 936 nodes (total 5616 GPUs) and one TPU Pod (V3-512 or V3-1024). We validated the advantage of up-scaling LMs to larger models supported by bigger data by predicting secondary structure (3-states: Q3=76-84, 8 states: Q8=65-73), sub-cellular localization for 10 cellular compartments (Q10=74) and whether a protein is membrane-bound or water-soluble (Q2=89). Dimensionality reduction revealed that the LM-embeddings from unlabeled data (only protein sequences) captured important biophysical properties governing protein shape. This implied learning some of the grammar of the language of life realized in protein sequences. The successful up-scaling of protein LMs through HPC to larger data sets slightly reduced the gap between models trained on evolutionary information and LMs. Availability ProtTrans: \<a href="https://github.com/agemagician/ProtTrans"\>https://github.com/agemagician/ProtTrans\</a\>Competing Interest StatementThe authors have declared no competing interest.},
+	URL = {https://www.biorxiv.org/content/early/2020/07/21/2020.07.12.199554},
+	eprint = {https://www.biorxiv.org/content/early/2020/07/21/2020.07.12.199554.full.pdf},
+	journal = {bioRxiv}
+}
+```
+
+> Created by [Ahmed Elnaggar/@Elnaggar_AI](https://twitter.com/Elnaggar_AI) | [LinkedIn](https://www.linkedin.com/in/prof-ahmed-elnaggar/)

modelsBioembed/config.json

@@ -0,0 +1,16 @@
+{
+  "architectures": [
+    "BertForMaskedLM"
+  ],
+  "attention_probs_dropout_prob": 0.0,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.0,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "max_position_embeddings": 40000,
+  "num_attention_heads": 16,
+  "num_hidden_layers": 30,
+  "type_vocab_size": 2,
+  "vocab_size": 30
+}

modelsBioembed/special_tokens_map.json

@@ -0,0 +1 @@
+{"unk_token": "[UNK]", "sep_token": "[SEP]", "pad_token": "[PAD]", "cls_token": "[CLS]", "mask_token": "[MASK]"}

modelsBioembed/tokenizer_config.json

@@ -0,0 +1 @@
+{"do_lower_case": false, "special_tokens_map_file": null, "full_tokenizer_file": null}

modelsBioembed/vocab.txt

@@ -0,0 +1,30 @@
+[PAD]
+[UNK]
+[CLS]
+[SEP]
+[MASK]
+L
+A
+G
+V
+E
+S
+I
+K
+R
+D
+T
+P
+N
+Q
+F
+Y
+M
+H
+C
+W
+X
+U
+B
+Z
+O

models_folder/atom_types.txt

@@ -0,0 +1,67 @@
+P,0,0
+F,0,0
+O,0,1
+Sn,0,0
+K,0,0
+S,0,2
+Fe,-2,0
+Cl,3,0
+Zn,2,0
+S,-1,0
+O,-1,0
+N,1,1
+Cl,1,0
+C,-1,0
+N,1,2
+Na,0,0
+V,0,0
+C,0,1
+N,1,0
+N,-1,1
+Li,0,0
+N,1,3
+I,1,0
+B,-1,0
+N,0,0
+Re,0,0
+O,1,0
+S,1,1
+N,0,1
+B,0,0
+N,-2,0
+N,0,3
+F,0,1
+O,0,0
+S,0,0
+O,0,2
+Br,0,1
+Ca,2,0
+Se,0,0
+Ru,0,0
+P,0,1
+B,-1,3
+Fe,0,0
+S,-1,1
+C,1,0
+C,0,0
+Si,0,0
+O,1,1
+I,0,0
+Hg,0,0
+C,0,3
+C,-1,1
+Br,0,0
+H,0,0
+Na,1,0
+I,0,1
+Sb,0,0
+Te,0,0
+C,0,2
+S,0,1
+P,0,2
+P,-1,0
+Cl,0,0
+P,1,0
+C,-1,2
+S,1,0
+N,-1,0

models_folder/configs.json

@@ -0,0 +1 @@
+{"N_C": 1024, "F_e": 16, "F_h": [32, 64, 128, 128, 256, 256], "F_skip": 256, "F_c": [512], "Fh_policy": 128, "activation": "relu", "rename": false, "N_rnn": 3}

modelstrc.py

@@ -0,0 +1,1331 @@
+import rdkit
+from rdkit import Chem
+from rdkit.Chem import Draw
+from rdkit import DataStructs
+from rdkit.Chem import AllChem
+from rdkit.Chem import rdmolfiles
+from rdkit.Chem.Draw import IPythonConsole
+from molvs import standardize_smiles
+import os
+import gc
+import sys
+import time
+import json
+import math
+import random
+import argparse
+import itertools
+import numpy as np
+import mxnet as mx
+import pandas as pd
+import networkx as nx
+from scipy import sparse
+from mxnet.gluon import nn
+from collections import Counter
+from mxnet.autograd import Function
+from mxnet.gluon.data import Dataset
+from mxnet import gluon, autograd, nd
+from mxnet.gluon.data import DataLoader
+from abc import ABCMeta, abstractmethod
+from mxnet.gluon.data.sampler import Sampler
+
+class MoleculeSpec(object):
+
+    def __init__(self, file_name='models_folder/atom_types.txt'):
+        self.atom_types = []
+        self.atom_symbols = []
+        with open(file_name) as f:
+            for line in f:
+                atom_type_i = line.strip('\n').split(',')
+                self.atom_types.append((atom_type_i[0], int(atom_type_i[1]), int(atom_type_i[2])))
+                if atom_type_i[0] not in self.atom_symbols:
+                    self.atom_symbols.append(atom_type_i[0])
+        self.bond_orders = [Chem.BondType.AROMATIC,
+                            Chem.BondType.SINGLE,
+                            Chem.BondType.DOUBLE,
+                            Chem.BondType.TRIPLE]
+        self.max_iter = 120
+
+    def get_atom_type(self, atom):
+        atom_symbol = atom.GetSymbol()
+        atom_charge = atom.GetFormalCharge()
+        atom_hs = atom.GetNumExplicitHs()
+        return self.atom_types.index((atom_symbol, atom_charge, atom_hs))
+
+    def get_bond_type(self, bond):
+        return self.bond_orders.index(bond.GetBondType())
+
+    def index_to_atom(self, idx):
+        atom_symbol, atom_charge, atom_hs = self.atom_types[idx]
+        a = Chem.Atom(atom_symbol)
+        a.SetFormalCharge(atom_charge)
+        a.SetNumExplicitHs(atom_hs)
+        return a
+
+    def index_to_bond(self, mol, begin_id, end_id, idx):
+        mol.AddBond(begin_id, end_id, self.bond_orders[idx])
+
+    @property
+    def num_atom_types(self):
+        return len(self.atom_types)
+
+    @property
+    def num_bond_types(self):
+        return len(self.bond_orders)
+
+_mol_spec = None
+
+def get_mol_spec():
+    global _mol_spec
+    if _mol_spec is None:
+        _mol_spec = MoleculeSpec()
+    return _mol_spec
+
+
+def get_graph_from_smiles(smiles):
+    mol = Chem.MolFromSmiles(smiles)
+
+    # build graph
+    atom_types, atom_ranks, bonds, bond_types = [], [], [], []
+    for a, r in zip(mol.GetAtoms(), Chem.CanonicalRankAtoms(mol)):
+        atom_types.append(get_mol_spec().get_atom_type(a))
+        atom_ranks.append(r)
+    for b in mol.GetBonds():
+        idx_1, idx_2, bt = b.GetBeginAtomIdx(), b.GetEndAtomIdx(), get_mol_spec().get_bond_type(b)
+        bonds.append([idx_1, idx_2])
+        bond_types.append(bt)
+
+    # build nx graph
+    graph = nx.Graph()
+    graph.add_nodes_from(range(len(atom_types)))
+    graph.add_edges_from(bonds)
+
+    return graph, atom_types, atom_ranks, bonds, bond_types
+
+
+def get_graph_from_smiles_list(smiles_list):
+    graph_list = []
+    for smiles in smiles_list:
+        mol = Chem.MolFromSmiles(smiles)
+
+        # build graph
+        atom_types, bonds, bond_types = [], [], []
+        for a in mol.GetAtoms():
+            atom_types.append(get_mol_spec().get_atom_type(a))
+        for b in mol.GetBonds():
+            idx_1, idx_2, bt = b.GetBeginAtomIdx(), b.GetEndAtomIdx(), get_mol_spec().get_bond_type(b)
+            bonds.append([idx_1, idx_2])
+            bond_types.append(bt)
+
+        X_0 = np.array(atom_types, dtype=np.int64)
+        A_0 = np.concatenate([np.array(bonds, dtype=np.int64),
+                              np.array(bond_types, dtype=np.int64)[:, np.newaxis]],
+                             axis=1)
+        graph_list.append([X_0, A_0])
+    return graph_list
+
+
+def traverse_graph(graph, atom_ranks, current_node=None, step_ids=None, p=0.9, log_p=0.0):
+    if current_node is None:
+        next_nodes = range(len(atom_ranks))
+        step_ids = [-1, ] * len(next_nodes)
+        next_node_ranks = atom_ranks
+    else:
+        next_nodes = graph.neighbors(current_node)  # get neighbor nodes
+        next_nodes = [n for n in next_nodes if step_ids[n] < 0] # filter visited nodes
+        next_node_ranks = [atom_ranks[n] for n in next_nodes] # get ranks for neighbors
+    next_nodes = [n for n, r in sorted(zip(next_nodes, next_node_ranks), key=lambda _x:_x[1])] # sort by rank
+
+    # iterate through neighbors
+    while len(next_nodes) > 0:
+        if len(next_nodes)==1:
+            next_node = next_nodes[0]
+        elif random.random() >= (1 - p):
+            next_node = next_nodes[0]
+            log_p += np.log(p)
+        else:
+            next_node = next_nodes[random.randint(1, len(next_nodes) - 1)]
+            log_p += np.log((1.0 - p) / (len(next_nodes) - 1))
+        step_ids[next_node] = max(step_ids) + 1
+        _, log_p = traverse_graph(graph, atom_ranks, next_node, step_ids, p, log_p)
+        next_nodes = [n for n in next_nodes if step_ids[n] < 0] # filter visited nodes
+
+    return step_ids, log_p
+
+
+def single_reorder(X_0, A_0, step_ids):
+    X_0, A_0 = np.copy(X_0), np.copy(A_0)
+
+    step_ids = np.array(step_ids, dtype=np.int64)
+
+    # sort by step_ids
+    sorted_ids = np.argsort(step_ids)
+    X_0 = X_0[sorted_ids]
+    A_0[:, 0], A_0[:, 1] = step_ids[A_0[:, 0]], step_ids[A_0[:, 1]]
+    max_b, min_b = np.amax(A_0[:, :2], axis=1), np.amin(A_0[:, :2], axis=1)
+    A_0 = A_0[np.lexsort([-min_b, max_b]), :]
+
+    # separate append and connect
+    max_b, min_b = np.amax(A_0[:, :2], axis=1), np.amin(A_0[:, :2], axis=1)
+    is_append = np.concatenate([np.array([True]), max_b[1:] > max_b[:-1]])
+    A_0 = np.concatenate([np.where(is_append[:, np.newaxis],
+                                 np.stack([min_b, max_b], axis=1),
+                                 np.stack([max_b, min_b], axis=1)),
+                        A_0[:, -1:]], axis=1)
+
+    return X_0, A_0
+
+
+def single_expand(X_0, A_0):
+    X_0, A_0 = np.copy(X_0), np.copy(A_0)
+
+    # expand X
+    is_append_iter = np.less(A_0[:, 0], A_0[:, 1]).astype(np.int64)
+    NX = np.cumsum(np.pad(is_append_iter, [[1, 0]], mode='constant', constant_values=1))
+    shift = np.cumsum(np.pad(NX, [[1, 0]], mode='constant')[:-1])
+    X_index = np.arange(NX.sum(), dtype=np.int64) - np.repeat(shift, NX)
+    X = X_0[X_index]
+
+    # expand A
+    _, A_index = np.tril_indices(A_0.shape[0])
+    A = A_0[A_index, :]
+    NA = np.arange(A_0.shape[0] + 1)
+
+    # get action
+    # action_type, atom_type, bond_type, append_pos, connect_pos
+    action_type = 1 - is_append_iter
+    atom_type = np.where(action_type == 0, X_0[A_0[:, 1]], 0)
+    bond_type = A_0[:, 2]
+    append_pos = np.where(action_type == 0, A_0[:, 0], 0)
+    connect_pos = np.where(action_type == 1, A_0[:, 1], 0)
+    actions = np.stack([action_type, atom_type, bond_type, append_pos, connect_pos],
+                       axis=1)
+    last_action = [[2, 0, 0, 0, 0]]
+    actions = np.append(actions, last_action, axis=0)
+
+    action_0 = np.array([X_0[0]], dtype=np.int64)
+
+    # }}}
+
+    # {{{ Get mask
+    last_atom_index = shift + NX - 1
+    last_atom_mask = np.zeros_like(X)
+    last_atom_mask[last_atom_index] = np.where(
+        np.pad(is_append_iter, [[1, 0]], mode='constant', constant_values=1) == 1,
+        np.ones_like(last_atom_index),
+        np.ones_like(last_atom_index) * 2)
+    # }}}
+
+    return action_0, X, NX, A, NA, actions, last_atom_mask
+
+
+def get_d(A, X):
+    _to_sparse = lambda _A, _X: sparse.coo_matrix((np.ones([_A.shape[0] * 2], dtype=np.int64),
+                                                   (np.concatenate([_A[:, 0], _A[:, 1]], axis=0),
+                                                    np.concatenate([_A[:, 1], _A[:, 0]], axis=0))),
+                                                  shape=[_X.shape[0], ] * 2)
+    A_sparse = _to_sparse(A, X)
+
+    d2 = A_sparse * A_sparse
+    d3 = d2 * A_sparse
+
+    # get D_2
+    D_2 = np.stack(d2.nonzero(), axis=1)
+    D_2 = D_2[D_2[:, 0] < D_2[:, 1], :]
+
+    # get D_3
+    D_3 = np.stack(d3.nonzero(), axis=1)
+    D_3 = D_3[D_3[:, 0] < D_3[:, 1], :]
+
+    # remove D_1 elements from D_3
+    D_3_sparse = _to_sparse(D_3, X)
+    D_3_sparse = D_3_sparse - D_3_sparse.multiply(A_sparse)
+    D_3 = np.stack(D_3_sparse.nonzero(), axis=1)
+    D_3 = D_3[D_3[:, 0] < D_3[:, 1], :]
+
+    return D_2, D_3
+
+
+def merge_single_0(X_0, A_0, NX_0, NA_0):
+    # shift_ids
+    cumsum = np.cumsum(np.pad(NX_0, [[1, 0]], mode='constant')[:-1])
+    A_0[:, :2] += np.stack([np.repeat(cumsum, NA_0), ] * 2, axis=1)
+
+    # get D
+    D_0_2, D_0_3 = get_d(A_0, X_0)
+
+    # split A
+    A_split = []
+    for i in range(get_mol_spec().num_bond_types):
+        A_i = A_0[A_0[:, 2] == i, :2]
+        A_split.append(A_i)
+    A_split.extend([D_0_2, D_0_3])
+    A_0 = A_split
+
+    # NX_rep
+    NX_rep_0 = np.repeat(np.arange(NX_0.shape[0]), NX_0)
+
+    return X_0, A_0, NX_0, NX_rep_0
+
+
+def merge_single(X, A,
+                 NX, NA,
+                 mol_ids, rep_ids, iw_ids,
+                 action_0, actions,
+                 last_append_mask,
+                 log_p):
+    X, A, NX, NX_rep = merge_single_0(X, A, NX, NA)
+    cumsum = np.cumsum(np.pad(NX, [[1, 0]], mode='constant')[:-1])
+    actions[:, -2] += cumsum * (actions[:, 0] == 0)
+    actions[:, -1] += cumsum * (actions[:, 0] == 1)
+    mol_ids_rep = np.repeat(mol_ids, NX)
+    rep_ids_rep = np.repeat(rep_ids, NX)
+
+    return X, A,\
+           mol_ids_rep, rep_ids_rep, iw_ids,\
+           last_append_mask,\
+           NX, NX_rep,\
+           action_0, actions, \
+           log_p
+
+def process_single(smiles, k, p):
+    graph, atom_types, atom_ranks, bonds, bond_types = get_graph_from_smiles(smiles)
+
+    # original
+    X_0 = np.array(atom_types, dtype=np.int64)
+    A_0 = np.concatenate([np.array(bonds, dtype=np.int64),
+                          np.array(bond_types, dtype=np.int64)[:, np.newaxis]],
+                         axis=1)
+
+    X, A = [], []
+    NX, NA = [], []
+    mol_ids, rep_ids, iw_ids = [], [], []
+    action_0, actions = [], []
+    last_append_mask = []
+    log_p = []
+
+    # random sampling decoding route
+    for i in range(k):
+        step_ids_i, log_p_i = traverse_graph(graph, atom_ranks, p=p)
+        X_i, A_i = single_reorder(X_0, A_0, step_ids_i)
+        action_0_i, X_i, NX_i, A_i, NA_i, actions_i, last_atom_mask_i = single_expand(X_i, A_i)
+
+        # appends
+        X.append(X_i)
+        A.append(A_i)
+        NX.append(NX_i)
+        NA.append(NA_i)
+        action_0.append(action_0_i)
+        actions.append(actions_i)
+        last_append_mask.append(last_atom_mask_i)
+
+        mol_ids.append(np.zeros_like(NX_i, dtype=np.int64))
+        rep_ids.append(np.ones_like(NX_i, dtype=np.int64) * i)
+        iw_ids.append(np.ones_like(NX_i, dtype=np.int64) * i)
+
+        log_p.append(log_p_i)
+
+    # concatenate
+    X = np.concatenate(X, axis=0)
+    A = np.concatenate(A, axis = 0)
+    NX = np.concatenate(NX, axis = 0)
+    NA = np.concatenate(NA, axis = 0)
+    action_0 = np.concatenate(action_0, axis = 0)
+    actions = np.concatenate(actions, axis = 0)
+    last_append_mask = np.concatenate(last_append_mask, axis = 0)
+    mol_ids = np.concatenate(mol_ids, axis = 0)
+    rep_ids = np.concatenate(rep_ids, axis = 0)
+    iw_ids = np.concatenate(iw_ids, axis = 0)
+    log_p = np.array(log_p, dtype=np.float32)
+
+    return X, A, NX, NA, mol_ids, rep_ids, iw_ids, action_0, actions, last_append_mask, log_p
+
+
+# noinspection PyArgumentList
+def get_mol_from_graph(X, A, sanitize=True):
+    try:
+        mol = Chem.RWMol(Chem.Mol())
+
+        X, A = X.tolist(), A.tolist()
+        for i, atom_type in enumerate(X):
+            mol.AddAtom(get_mol_spec().index_to_atom(atom_type))
+
+        for atom_id1, atom_id2, bond_type in A:
+            get_mol_spec().index_to_bond(mol, atom_id1, atom_id2, bond_type)
+    except:
+        return None
+
+    if sanitize:
+        try:
+            mol = mol.GetMol()
+            Chem.SanitizeMol(mol)
+            return mol
+        except:
+            return None
+    else:
+        return mol
+
+def get_mol_from_graph_list(graph_list, sanitize=True):
+    mol_list = [get_mol_from_graph(X, A, sanitize) for X, A in graph_list]
+    return mol_list
+
+class GraphConvFn(Function):
+
+    def __init__(self, A):
+        self.A = A # type: nd.sparse.CSRNDArray
+        self.A_T = self.A # assume symmetric
+        super(GraphConvFn, self).__init__()
+
+    def forward(self, X):
+        if self.A is not None:
+            if len(X.shape) > 2:
+                X_resized = X.reshape((X.shape[0], -1))
+                output = nd.sparse.dot(self.A, X_resized)
+                output = output.reshape([-1, ] + [X.shape[i] for i in range(1, len(X.shape))])
+            else:
+                output = nd.sparse.dot(self.A, X)
+            return output
+        else:
+            return nd.zeros_like(X)
+
+    def backward(self, grad_output):
+
+        if self.A is not None:
+            if len(grad_output.shape) > 2:
+                grad_output_resized = grad_output.reshape((grad_output.shape[0], -1))
+                grad_input = nd.sparse.dot(self.A_T, grad_output_resized)
+                grad_input = grad_input.reshape([-1] + [grad_output.shape[i]
+                                                        for i in range(1, len(grad_output.shape))])
+            else:
+                grad_input = nd.sparse.dot(self.A_T, grad_output)
+            return grad_input
+        else:
+            return nd.zeros_like(grad_output)
+
+
+class EfficientGraphConvFn(Function):
+    """Save memory by re-computation"""
+
+    def __init__(self, A_list):
+        self.A_list = A_list
+        super(EfficientGraphConvFn, self).__init__()
+
+    def forward(self, X, W):
+        X_list = [X]
+        for A in self.A_list:
+            if A is not None:
+                X_list.append(nd.sparse.dot(A, X))
+            else:
+                X_list.append(nd.zeros_like(X))
+        X_out = nd.concat(*X_list, dim=1)
+        self.save_for_backward(X, W)
+
+        return nd.dot(X_out, W)
+
+    def backward(self, grad_output):
+        X, W = self.saved_tensors
+
+        # recompute X_out
+        X_list = [X, ]
+        for A in self.A_list:
+            if A is not None:
+                X_list.append(nd.sparse.dot(A, X))
+            else:
+                X_list.append(nd.zeros_like(X))
+        X_out = nd.concat(*X_list, dim=1)
+
+        grad_W = nd.dot(X_out.T, grad_output)
+
+        grad_X_out = nd.dot(grad_output, W.T)
+        grad_X_out_list = nd.split(grad_X_out, num_outputs=len(self.A_list) + 1)
+
+
+        grad_X = [grad_X_out_list[0], ]
+        for A, grad_X_out in zip(self.A_list, grad_X_out_list[1:]):
+            if A is not None:
+                grad_X.append(nd.sparse.dot(A, grad_X_out))
+            else:
+                grad_X.append(nd.zeros_like(grad_X_out))
+
+        grad_X = sum(grad_X)
+
+        return grad_X, grad_W
+
+
+class SegmentSumFn(GraphConvFn):
+
+    def __init__(self, idx, num_seg):
+        # build A
+        # construct coo
+        data = nd.ones(idx.shape[0], ctx=idx.context, dtype='int64')
+        row, col = idx, nd.arange(idx.shape[0], ctx=idx.context, dtype='int64')
+        shape = (num_seg, int(idx.shape[0]))
+        sparse = nd.sparse.csr_matrix((data, (row, col)), shape=shape,
+                                      ctx=idx.context, dtype='float32')
+        super(SegmentSumFn, self).__init__(sparse)
+
+        sparse = nd.sparse.csr_matrix((data, (col, row)), shape=(shape[1], shape[0]),
+                                      ctx=idx.context, dtype='float32')
+        self.A_T = sparse
+
+
+def squeeze(input, axis):
+    assert input.shape[axis] == 1
+
+    new_shape = list(input.shape)
+    del new_shape[axis]
+
+    return input.reshape(new_shape)
+
+
+def unsqueeze(input, axis):
+    return nd.expand_dims(input, axis=axis)
+
+
+def logsumexp(inputs, axis=None, keepdims=False):
+    """Numerically stable logsumexp.
+    Args:
+        inputs: A Variable with any shape.
+        axis: An integer.
+        keepdims: A boolean.
+    Returns:
+        Equivalent of log(sum(exp(inputs), dim=dim, keepdim=keepdim)).
+    Adopted from: https://github.com/pytorch/pytorch/issues/2591
+    """
+    # For a 1-D array x (any array along a single dimension),
+    # log sum exp(x) = s + log sum exp(x - s)
+    # with s = max(x) being a common choice.
+    if axis is None:
+        inputs = inputs.reshape([-1])
+        axis = 0
+    s = nd.max(inputs, axis=axis, keepdims=True)
+    outputs = s + (inputs - s).exp().sum(axis=axis, keepdims=True).log()
+    if not keepdims:
+        outputs = nd.sum(outputs, axis=axis, keepdims=False)
+    return outputs
+
+
+def get_activation(name):
+    activation_dict = {
+        'relu':nd.relu,
+        'tanh':nd.tanh
+    }
+    return activation_dict[name]
+
+
+
+class Linear_BN(nn.Sequential):
+    def __init__(self, F_in, F_out):
+        super(Linear_BN, self).__init__()
+        self.add(nn.Dense(F_out, in_units=F_in, use_bias=False))
+        self.add(BatchNorm(in_channels=F_out))
+
+
+class GraphConv(nn.Block):
+
+    def __init__(self, Fin, Fout, D):
+        super(GraphConv, self).__init__()
+
+        # model settings
+        self.Fin = Fin
+        self.Fout = Fout
+        self.D = D
+
+        # model parameters
+        self.W = self.params.get('w', shape=(self.Fin * (self.D + 1), self.Fout),
+                                 init=None, allow_deferred_init=False)
+
+    def forward(self, X, A_list):
+        try:
+            assert len(A_list) == self.D
+        except AssertionError as e:
+            print(self.D, len(A_list))
+            raise e
+        return EfficientGraphConvFn(A_list)(X, self.W.data(X.context))
+
+
+class Policy(nn.Block):
+
+    def __init__(self, F_in, F_h, N_A, N_B, k=1):
+        super(Policy, self).__init__()
+        self.F_in = F_in # number of input features for each atom
+        self.F_h = F_h # number of context variables
+        self.N_A = N_A # number of atom types
+        self.N_B = N_B # number of bond types
+        self.k = k # number of softmax used in the mixture
+
+
+        with self.name_scope():
+            self.linear_h = Linear_BN(F_in * 2, self.F_h * k)
+            self.linear_h_t = Linear_BN(F_in, self.F_h * k)
+
+            self.linear_x = nn.Dense(self.N_B + self.N_B*self.N_A, in_units=self.F_h)
+            self.linear_x_t = nn.Dense(1, in_units=self.F_h)
+
+            if self.k > 1:
+                self.linear_pi = nn.Dense(self.k, in_units=self.F_in)
+            else:
+                self.linear_pi = None
+
+    def forward(self, X, NX, NX_rep, X_end=None):
+        # segment mean for X
+        if X_end is None:
+            X_end = SegmentSumFn(NX_rep, NX.shape[0])(X)/nd.cast(fn.unsqueeze(NX, 1), 'float32')
+        X = nd.concat(X, X_end[NX_rep, :], dim=1)
+
+        X_h = nd.relu(self.linear_h(X)).reshape([-1, self.F_h])
+        X_h_end = nd.relu(self.linear_h_t(X_end)).reshape([-1, self.F_h])
+
+        X_x = nd.exp(self.linear_x(X_h)).reshape([-1, self.k, self.N_B + self.N_B*self.N_A])
+        X_x_end = nd.exp(self.linear_x_t(X_h_end)).reshape([-1, self.k, 1])
+
+        X_sum = nd.sum(SegmentSumFn(NX_rep, NX.shape[0])(X_x), -1, keepdims=True) + X_x_end
+        X_sum_gathered = X_sum[NX_rep, :, :]
+
+        X_softmax = X_x / X_sum_gathered
+        X_softmax_end = X_x_end/ X_sum
+
+        if self.k > 1:
+            pi = unsqueeze(nd.softmax(self.linear_pi(X_end), axis=1), -1)
+            pi_gathered = pi[NX_rep, :, :]
+
+            X_softmax = nd.sum(X_softmax * pi_gathered, axis=1)
+            X_softmax_end = nd.sum(X_softmax_end * pi, axis=1)
+        else:
+            X_softmax = squeeze(X_softmax, 1)
+            X_softmax_end = squeeze(X_softmax_end, 1)
+
+        # generate output probabilities
+        connect, append = X_softmax[:, :self.N_B], X_softmax[:, self.N_B:]
+        append = append.reshape([-1, self.N_A, self.N_B])
+        end = squeeze(X_softmax_end, -1)
+
+        return append, connect, end
+
+
+class BatchNorm(nn.Block):
+
+    def __init__(self, in_channels, momentum=0.9, eps=1e-5):
+        super(BatchNorm, self).__init__()
+        self.F = in_channels
+
+        self.bn_weight = self.params.get('bn_weight', shape=(self.F,), init=mx.init.One(),
+                                         allow_deferred_init=False)
+        self.bn_bias = self.params.get('bn_bias', shape=(self.F,), init=mx.init.Zero(),
+                                       allow_deferred_init=False)
+
+        self.running_mean = self.params.get('running_mean', grad_req='null',
+                                            shape=(self.F,),
+                                            init=mx.init.Zero(),
+                                            allow_deferred_init=False,
+                                            differentiable=False)
+        self.running_var = self.params.get('running_var', grad_req='null',
+                                           shape=(self.F,),
+                                           init=mx.init.One(),
+                                           allow_deferred_init=False,
+                                           differentiable=False)
+        self.momentum = momentum
+        self.eps = eps
+
+    def forward(self, x):
+        if autograd.is_training():
+            return nd.BatchNorm(x,
+                                gamma=self.bn_weight.data(x.context),
+                                beta=self.bn_bias.data(x.context),
+                                moving_mean=self.running_mean.data(x.context),
+                                moving_var=self.running_var.data(x.context),
+                                eps=self.eps, momentum=self.momentum,
+                                use_global_stats=False)
+        else:
+            return nd.BatchNorm(x,
+                                gamma=self.bn_weight.data(x.context),
+                                beta=self.bn_bias.data(x.context),
+                                moving_mean=self.running_mean.data(x.context),
+                                moving_var=self.running_var.data(x.context),
+                                eps=self.eps, momentum=self.momentum,
+                                use_global_stats=True)
+        
+class MoleculeGenerator(nn.Block):
+
+    __metaclass__ = ABCMeta
+
+    def __init__(self, N_A, N_B, D, F_e, F_skip, F_c, Fh_policy, activation,
+                 *args, **kwargs):
+        super(MoleculeGenerator, self).__init__()
+        self.N_A = N_A
+        self.N_B = N_B
+        self.D = D
+        self.F_e = F_e
+        self.F_skip = F_skip
+        self.F_c = list(F_c) if isinstance(F_c, tuple) else F_c
+        self.Fh_policy = Fh_policy
+        self.activation = get_activation(activation)
+
+        with self.name_scope():
+            # embeddings
+            self.embedding_atom = nn.Embedding(self.N_A, self.F_e)
+            self.embedding_mask = nn.Embedding(3, self.F_e)
+
+            # graph conv
+            self._build_graph_conv(*args, **kwargs)
+
+            # fully connected
+            self.dense = nn.Sequential()
+            for i, (f_in, f_out) in enumerate(zip([self.F_skip, ] + self.F_c[:-1], self.F_c)):
+                self.dense.add(Linear_BN(f_in, f_out))
+
+            # policy
+            self.policy_0 = self.params.get('policy_0', shape=[self.N_A, ],
+                                            init=mx.init.Zero(),
+                                            allow_deferred_init=False)
+            self.policy_h = Policy(self.F_c[-1], self.Fh_policy, self.N_A, self.N_B)
+
+        self.mode = 'loss'
+
+    @abstractmethod
+    def _build_graph_conv(self, *args, **kwargs):
+        raise NotImplementedError
+
+    @abstractmethod
+    def _graph_conv_forward(self, X, A):
+        raise NotImplementedError
+
+    def _policy_0(self, ctx):
+        policy_0 = nd.exp(self.policy_0.data(ctx))
+        policy_0 = policy_0/policy_0.sum()
+        return policy_0
+
+    def _policy(self, X, A, NX, NX_rep, last_append_mask):
+        # get initial embedding
+        X = self.embedding_atom(X) + self.embedding_mask(last_append_mask)
+
+        # convolution
+        X = self._graph_conv_forward(X, A)
+
+        # linear
+        X = self.dense(X)
+
+        # policy
+        append, connect, end = self.policy_h(X, NX, NX_rep)
+
+        return append, connect, end
+
+    def _likelihood(self, init, append, connect, end,
+                    action_0, actions, iw_ids, log_p_sigma,
+                    batch_size, iw_size):
+
+        # decompose action:
+        action_type, node_type, edge_type, append_pos, connect_pos = \
+            actions[:, 0], actions[:, 1], actions[:, 2], actions[:, 3], actions[:, 4]
+        _log_mask = lambda _x, _mask: _mask * nd.log(_x + 1e-10) + (1- _mask) * nd.zeros_like(_x)
+
+        # init
+        init = init.reshape([batch_size * iw_size, self.N_A])
+        index = nd.stack(nd.arange(action_0.shape[0], ctx=action_0.context, dtype='int64'), action_0, axis=0)
+        loss_init = nd.log(nd.gather_nd(init, index) + 1e-10)
+
+        # end
+        loss_end = _log_mask(end, nd.cast(action_type == 2, 'float32'))
+
+        # append
+        index = nd.stack(append_pos, node_type, edge_type, axis=0)
+        loss_append = _log_mask(nd.gather_nd(append, index), nd.cast(action_type == 0, 'float32'))
+
+        # connect
+        index = nd.stack(connect_pos, edge_type, axis=0)
+        loss_connect = _log_mask(nd.gather_nd(connect, index), nd.cast(action_type == 1, 'float32'))
+
+        # sum up results
+        log_p_x = loss_end + loss_append + loss_connect
+        log_p_x = squeeze(SegmentSumFn(iw_ids, batch_size*iw_size)(unsqueeze(log_p_x, -1)), -1)
+        log_p_x = log_p_x + loss_init
+
+        # reshape
+        log_p_x = log_p_x.reshape([batch_size, iw_size])
+        log_p_sigma = log_p_sigma.reshape([batch_size, iw_size])
+        l = log_p_x - log_p_sigma
+        l = logsumexp(l, axis=1) - math.log(float(iw_size))
+        return l
+
+    def forward(self, *input):
+        if self.mode=='loss' or self.mode=='likelihood':
+            X, A, iw_ids, last_append_mask, \
+            NX, NX_rep, action_0, actions, log_p, \
+            batch_size, iw_size = input
+
+            init = self._policy_0(X.context).tile([batch_size * iw_size, 1])
+            append, connect, end = self._policy(X, A, NX, NX_rep, last_append_mask)
+            l = self._likelihood(init, append, connect, end, action_0, actions, iw_ids, log_p, batch_size, iw_size)
+            if self.mode=='likelihood':
+                return l
+            else:
+                return -l.mean()
+        elif self.mode == 'decode_0':
+            return self._policy_0(input[0])
+        elif self.mode == 'decode_step':
+            X, A, NX, NX_rep, last_append_mask = input
+            return self._policy(X, A, NX, NX_rep, last_append_mask)
+
+
+class MoleculeGenerator_RNN(MoleculeGenerator):
+
+    __metaclass__ = ABCMeta
+
+    def __init__(self, N_A, N_B, D, F_e, F_skip, F_c, Fh_policy, activation,
+                 N_rnn, *args, **kwargs):
+        super(MoleculeGenerator_RNN, self).__init__(N_A, N_B, D, F_e, F_skip, F_c, Fh_policy, activation,
+                                                    *args, **kwargs)
+        self.N_rnn = N_rnn
+
+        with self.name_scope():
+            self.rnn = gluon.rnn.GRU(hidden_size=self.F_c[-1],
+                                     num_layers=self.N_rnn,
+                                     layout='NTC', input_size=self.F_c[-1] * 2)
+
+    def _rnn_train(self, X, NX, NX_rep, graph_to_rnn, rnn_to_graph, NX_cum):
+        X_avg = SegmentSumFn(NX_rep, NX.shape[0])(X) / nd.cast(unsqueeze(NX, 1), 'float32')
+        X_curr = nd.take(X, indices=NX_cum-1)
+        X = nd.concat(X_avg, X_curr, dim=1)
+
+        # rnn
+        X = nd.take(X, indices=graph_to_rnn) # batch_size, iw_size, length, num_features
+        batch_size, iw_size, length, num_features = X.shape
+        X = X.reshape([batch_size*iw_size, length, num_features])
+        X = self.rnn(X)
+
+        X = X.reshape([batch_size, iw_size, length, -1])
+        X = nd.gather_nd(X, indices=rnn_to_graph)
+
+        return X
+
+    def _rnn_test(self, X, NX, NX_rep, NX_cum, h):
+        # note: one partition for one molecule
+        X_avg = SegmentSumFn(NX_rep, NX.shape[0])(X) / nd.cast(unsqueeze(NX, 1), 'float32')
+        X_curr = nd.take(X, indices=NX_cum - 1)
+        X = nd.concat(X_avg, X_curr, dim=1) # size: [NX, F_in * 2]
+
+        # rnn
+        X = unsqueeze(X, axis=1)
+        X, h = self.rnn(X, h)
+
+        X = squeeze(X, axis=1)
+        return X, h
+
+    def _policy(self, X, A, NX, NX_rep, last_append_mask, graph_to_rnn, rnn_to_graph, NX_cum):
+        # get initial embedding
+        X = self.embedding_atom(X) + self.embedding_mask(last_append_mask)
+
+        # convolution
+        X = self._graph_conv_forward(X, A)
+
+        # linear
+        X = self.dense(X)
+
+        # rnn
+        X_mol = self._rnn_train(X, NX, NX_rep, graph_to_rnn, rnn_to_graph, NX_cum)
+
+        # policy
+        append, connect, end = self.policy_h(X, NX, NX_rep, X_mol)
+
+        return append, connect, end
+
+    def _decode_step(self, X, A, NX, NX_rep, last_append_mask, NX_cum, h):
+        # get initial embedding
+        X = self.embedding_atom(X) + self.embedding_mask(last_append_mask)
+
+        # convolution
+        X = self._graph_conv_forward(X, A)
+
+        # linear
+        X = self.dense(X)
+
+        # rnn
+        X_mol, h = self._rnn_test(X, NX, NX_rep, NX_cum, h)
+
+        # policy
+        append, connect, end = self.policy_h(X, NX, NX_rep, X_mol)
+
+        return append, connect, end, h
+
+    def forward(self, *input):
+        if self.mode=='loss' or self.mode=='likelihood':
+            X, A, iw_ids, last_append_mask, \
+            NX, NX_rep, action_0, actions, log_p, \
+            batch_size, iw_size, \
+            graph_to_rnn, rnn_to_graph, NX_cum = input
+
+            init = self._policy_0(X.context).tile([batch_size * iw_size, 1])
+            append, connect, end = self._policy(X, A, NX, NX_rep, last_append_mask, graph_to_rnn, rnn_to_graph, NX_cum)
+            l = self._likelihood(init, append, connect, end, action_0, actions, iw_ids, log_p, batch_size, iw_size)
+            if self.mode=='likelihood':
+                return l
+            else:
+                return -l.mean()
+        elif self.mode == 'decode_0':
+            return self._policy_0(input[0])
+        elif self.mode == 'decode_step':
+            X, A, NX, NX_rep, last_append_mask, NX_cum, h = input
+            return self._decode_step(X, A, NX, NX_rep, last_append_mask, NX_cum, h)
+        else:
+            raise ValueError
+            
+class _TwoLayerDense(nn.Block):
+
+    def __init__(self, input_size, hidden_size, output_size):
+        super(_TwoLayerDense, self).__init__()
+
+        self.hidden_size = hidden_size
+        self.output_size = output_size
+        self.input_size = input_size
+
+        with self.name_scope():
+            # config 1
+            self.input = nn.Dense(self.hidden_size, use_bias=False, in_units=self.input_size)
+            self.bn_input = BatchNorm(in_channels=hidden_size)
+            self.output = nn.Dense(self.output_size, use_bias=True, in_units=self.hidden_size)
+            
+            # config 2
+            #self.output = nn.Dense(self.output_size, use_bias=True, in_units=self.input_size)
+            
+            # config 3
+            #self.input1 = nn.Dense(self.hidden_size, use_bias=False, in_units=self.input_size)
+            #self.bn_input1 = BatchNorm(in_channels=self.hidden_size)
+            #self.input2 = nn.Dense(self.hidden_size, use_bias=False, in_units=self.hidden_size)
+            #self.bn_input2 = BatchNorm(in_channels=self.hidden_size)
+            #self.output = nn.Dense(self.output_size, use_bias=True, in_units=self.hidden_size)
+            
+            # config 4
+            #self.bn_input = BatchNorm(in_channels=self.input_size)
+            #self.output = nn.Dense(self.output_size, use_bias=True, in_units=self.input_size)
+            
+            # config 5
+            #self.bn_input = BatchNorm(in_channels=1024)
+            #self.output = nn.Dense(self.output_size, use_bias=True, in_units=1024)
+            
+
+    def forward(self, c):
+        # config 1
+        return nd.softmax(self.output(nd.relu(self.bn_input(self.input(c)))), axis=-1)
+        
+        # config 2
+        #return nd.softmax(self.output(c), axis=-1)
+    
+        # config 3
+        #return nd.softmax(self.output(nd.relu(self.bn_input2(self.input2(nd.relu(self.bn_input1(self.input1(c))))))), axis=-1)
+        
+        # config 4
+        #return nd.softmax(self.output(nd.relu(self.bn_input(c))), axis=-1)
+        
+        # config 5
+        #return nd.softmax(self.output(c), axis=-1)
+
+
+class CMoleculeGenerator_RNN(MoleculeGenerator_RNN):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, N_A, N_B, N_C, D,
+                 F_e, F_skip, F_c, Fh_policy,
+                 activation, N_rnn,
+                 *args, **kwargs):
+        self.N_C = N_C # number of conditional variables
+        super(CMoleculeGenerator_RNN, self).__init__(N_A, N_B, D,
+                                                     F_e, F_skip, F_c, Fh_policy,
+                                                     activation, N_rnn,
+                                                     *args, **kwargs)
+        with self.name_scope():
+            self.dense_policy_0 = _TwoLayerDense(self.N_C, self.N_A * 3, self.N_A)
+
+    @abstractmethod
+    def _graph_conv_forward(self, X, A, c, ids):
+        raise NotImplementedError
+
+    def _policy_0(self, c):
+        return self.dense_policy_0(c) + 0.0 * self.policy_0.data(c.context)
+
+    def _policy(self, X, A, NX, NX_rep, last_append_mask,
+                graph_to_rnn, rnn_to_graph, NX_cum,
+                c, ids):
+        # get initial embedding
+        X = self.embedding_atom(X) + self.embedding_mask(last_append_mask)
+
+        # convolution
+        X = self._graph_conv_forward(X, A, c, ids)
+
+        # linear
+        X = self.dense(X)
+
+        # rnn
+        X_mol = self._rnn_train(X, NX, NX_rep, graph_to_rnn, rnn_to_graph, NX_cum)
+
+        # policy
+        append, connect, end = self.policy_h(X, NX, NX_rep, X_mol)
+
+        return append, connect, end
+
+    def _decode_step(self, X, A, NX, NX_rep, last_append_mask, NX_cum, h, c, ids):
+        # get initial embedding
+        X = self.embedding_atom(X) + self.embedding_mask(last_append_mask)
+
+        # convolution
+        X = self._graph_conv_forward(X, A, c, ids)
+
+        # linear
+        X = self.dense(X)
+
+        # rnn
+        X_mol, h = self._rnn_test(X, NX, NX_rep, NX_cum, h)
+
+        # policy
+        append, connect, end = self.policy_h(X, NX, NX_rep, X_mol)
+
+        return append, connect, end, h
+
+
+    def forward(self, *input):
+        if self.mode=='loss' or self.mode=='likelihood':
+            X, A, iw_ids, last_append_mask, \
+            NX, NX_rep, action_0, actions, log_p, \
+            batch_size, iw_size, \
+            graph_to_rnn, rnn_to_graph, NX_cum, \
+            c, ids = input
+
+            init = nd.tile(unsqueeze(self._policy_0(c), axis=1), [1, iw_size, 1])
+            append, connect, end = self._policy(X, A, NX, NX_rep, last_append_mask,
+                                                graph_to_rnn, rnn_to_graph, NX_cum,
+                                                c, ids)
+            l = self._likelihood(init, append, connect, end,
+                                 action_0, actions, iw_ids, log_p,
+                                 batch_size, iw_size)
+            if self.mode=='likelihood':
+                return l
+            else:
+                return -l.mean()
+        elif self.mode == 'decode_0':
+            return self._policy_0(*input)
+        elif self.mode == 'decode_step':
+            X, A, NX, NX_rep, last_append_mask, NX_cum, h, c, ids = input
+            return self._decode_step(X, A, NX, NX_rep, last_append_mask, NX_cum, h, c, ids)
+        else:
+            raise ValueError
+
+class CVanillaMolGen_RNN(CMoleculeGenerator_RNN):
+
+    def __init__(self, N_A, N_B, N_C, D,
+                 F_e, F_h, F_skip, F_c, Fh_policy,
+                 activation, N_rnn, rename=False):
+        self.rename = rename
+        super(CVanillaMolGen_RNN, self).__init__(N_A, N_B, N_C, D,
+                                                 F_e, F_skip, F_c, Fh_policy,
+                                                 activation, N_rnn,
+                                                 F_h)
+
+    def _build_graph_conv(self, F_h):
+        self.F_h = list(F_h) if isinstance(F_h, tuple) else F_h
+        self.conv, self.bn = [], []
+        for i, (f_in, f_out) in enumerate(zip([self.F_e] + self.F_h[:-1], self.F_h)):
+            conv = GraphConv(f_in, f_out, self.N_B + self.D)
+            self.conv.append(conv)
+            self.register_child(conv)
+
+            if i != 0:
+                bn = BatchNorm(in_channels=f_in)
+                self.register_child(bn)
+            else:
+                bn = None
+            self.bn.append(bn)
+
+        self.bn_skip = BatchNorm(in_channels=sum(self.F_h))
+        self.linear_skip = Linear_BN(sum(self.F_h), self.F_skip)
+
+        # projectors for conditional variable (protein embedding)
+        self.linear_c = []
+        for i, f_out in enumerate(self.F_h):
+            if self.rename:
+                linear_c = nn.Dense(f_out, use_bias=False, in_units=self.N_C, prefix='cond_{}'.format(i))
+            else:
+                linear_c = nn.Dense(f_out, use_bias=False, in_units=self.N_C)
+            self.register_child(linear_c)
+            self.linear_c.append(linear_c)
+
+    def _graph_conv_forward(self, X, A, c, ids):
+        X_out = [X]
+        for conv, bn, linear_c in zip(self.conv, self.bn, self.linear_c):
+            X = X_out[-1]
+            if bn is not None:
+                X_out.append(conv(self.activation(bn(X)), A) + linear_c(c)[ids, :])
+            else:
+                X_out.append(conv(X, A) + linear_c(c)[ids, :])
+        X_out = nd.concat(*X_out[1:], dim=1)
+        return self.activation(self.linear_skip(self.activation(self.bn_skip(X_out))))
+    
+def _decode_step(X, A, NX, NA, last_action, finished,
+                 get_init, get_action,
+                 random=False, n_node_types=get_mol_spec().num_atom_types,
+                 n_edge_types=get_mol_spec().num_bond_types):
+    if X is None:
+        init = get_init()
+
+        if random:
+            X = []
+            for i in range(init.shape[0]):
+                # init probabilities(for first atom)
+                p = init[i, :]
+                # Random sampling using init probability distribution
+                selected_atom = np.random.choice(np.arange(init.shape[1]), 1, p=p)[0]
+                X.append(selected_atom)
+            X = np.array(X, dtype=np.int64)
+        else:
+            X = np.argmax(init, axis=1)
+        A = np.zeros((0, 3), dtype=np.int64)
+        NX = last_action = np.ones([X.shape[0]], dtype=np.int64)
+        NA = np.zeros([X.shape[0]], dtype=np.int64)
+        finished = np.array([False, ] * X.shape[0], dtype=np.bool)
+
+        return X, A, NX, NA, last_action, finished
+    else:
+        X_u = X[np.repeat(np.logical_not(finished), NX)]
+        A_u = A[np.repeat(np.logical_not(finished), NA), :]
+        NX_u = NX[np.logical_not(finished)]
+        NA_u = NA[np.logical_not(finished)]
+        last_action_u = last_action[np.logical_not(finished)]
+
+        # conv
+        mol_ids_rep = NX_rep = np.repeat(np.arange(NX_u.shape[0]), NX_u)
+        rep_ids_rep = np.zeros_like(mol_ids_rep)
+
+        if A.shape[0] == 0:
+            D_2 = D_3 = np.zeros((0, 2), dtype=np.int64)
+            A_u = [np.zeros((0, 2), dtype=np.int64) for _ in range(get_mol_spec().num_bond_types)]
+            A_u += [D_2, D_3]
+        else:
+            cumsum = np.cumsum(np.pad(NX_u, [[1, 0]], mode='constant')[:-1])
+            shift = np.repeat(cumsum, NA_u)
+            A_u[:, :2] += np.stack([shift, ] * 2, axis=1)
+            D_2, D_3 = get_d(A_u, X_u)
+            A_u = [A_u[A_u[:, 2] == _i, :2] for _i in range(n_edge_types)]
+            A_u += [D_2, D_3]
+
+        mask = np.zeros([X_u.shape[0]], dtype=np.int64)
+        last_append_index = np.cumsum(NX_u) - 1
+        mask[last_append_index] = np.where(last_action_u == 1,
+                                           np.ones_like(last_append_index, dtype=np.int64),
+                                           np.ones_like(last_append_index, dtype=np.int64) * 2)
+
+        decode_input = [X_u, A_u, NX_u, NX_rep, mask, mol_ids_rep, rep_ids_rep]
+        append, connect, end = get_action(decode_input)
+
+        if A.shape[0] == 0:
+            max_index = np.argmax(np.reshape(append, [-1, n_node_types * n_edge_types]), axis=1)
+            atom_type, bond_type = np.unravel_index(max_index, [n_node_types, n_edge_types])
+            X = np.reshape(np.stack([X, atom_type], axis=1), [-1])
+            NX = np.array([2, ] * len(finished), dtype=np.int64)
+            A = np.stack([np.zeros([len(finished), ], dtype=np.int64),
+                          np.ones([len(finished), ], dtype=np.int64),
+                          bond_type], axis=1)
+            NA = np.ones([len(finished), ], dtype=np.int64)
+            last_action = np.ones_like(NX, dtype=np.int64)
+
+        else:
+            # process for each molecule
+            append, connect = np.split(append, np.cumsum(NX_u)), np.split(connect, np.cumsum(NX_u))
+            end = end.tolist()
+
+            unfinished_ids = np.where(np.logical_not(finished))[0].tolist()
+            cumsum = np.cumsum(NX)
+            cumsum_a = np.cumsum(NA)
+
+            X_insert = []
+            X_insert_ids = []
+            A_insert = []
+            A_insert_ids = []
+            finished_ids = []
+
+            for i, (unfinished_id, append_i, connect_i, end_i) \
+                    in enumerate(zip(unfinished_ids, append, connect, end)):
+                if random:
+                    def _rand_id(*_x):
+                        _x_reshaped = [np.reshape(_xi, [-1]) for _xi in _x]
+                        _x_length = np.array([_x_reshape_i.shape[0] for _x_reshape_i in _x_reshaped],
+                                             dtype=np.int64)
+                        _begin = np.cumsum(np.pad(_x_length, [[1, 0]], mode='constant')[:-1])
+                        _end = np.cumsum(_x_length) - 1
+                        _p = np.concatenate(_x_reshaped)
+                        _p = _p / np.sum(_p)
+                        # Count NaN values
+                        num_nan = np.isnan(_p).sum()
+                        if num_nan > 0:
+                            print(f'Number of NaN values in _p: {num_nan}')
+                            _rand_index = np.random.choice(np.arange(len(_p)), 1)[0]
+
+                        else:
+                            _rand_index = np.random.choice(np.arange(_p.shape[0]), 1, p=_p)[0]
+                            
+                        
+                        _p_step = _p[_rand_index]
+                        _x_index = np.where(np.logical_and(_begin <= _rand_index, _end >= _rand_index))[0][0]
+                        _rand_index = _rand_index - _begin[_x_index]
+                        _rand_index = np.unravel_index(_rand_index, _x[_x_index].shape)
+                        return _x_index, _rand_index, _p_step
+
+                    action_type, action_index, p_step = _rand_id(append_i, connect_i, np.array([end_i]))
+                else:
+                    _argmax = lambda _x: np.unravel_index(np.argmax(_x), _x.shape)
+                    append_id, append_val = _argmax(append_i), np.max(append_i)
+                    connect_id, connect_val = _argmax(connect_i), np.max(connect_i)
+                    end_val = end_i
+                    if end_val >= append_val and end_val >= connect_val:
+                        action_type = 2
+                        action_index = None
+                    elif append_val >= connect_val and append_val >= end_val:
+                        action_type = 0
+                        action_index = append_id
+                    else:
+                        action_type = 1
+                        action_index = connect_id
+                if action_type == 2:
+                    # finish growth
+                    finished_ids.append(unfinished_id)
+                elif action_type == 0:
+                    # append action
+                    append_pos, atom_type, bond_type = action_index
+                    X_insert.append(atom_type)
+                    X_insert_ids.append(unfinished_id)
+                    A_insert.append([append_pos, NX[unfinished_id], bond_type])
+                    A_insert_ids.append(unfinished_id)
+                else:
+                    # connect
+                    connect_ps, bond_type = action_index
+                    A_insert.append([NX[unfinished_id] - 1, connect_ps, bond_type])
+                    A_insert_ids.append(unfinished_id)
+            if len(A_insert_ids) > 0:
+                A = np.insert(A, cumsum_a[A_insert_ids], A_insert, axis=0)
+                NA[A_insert_ids] += 1
+                last_action[A_insert_ids] = 0
+            if len(X_insert_ids) > 0:
+                X = np.insert(X, cumsum[X_insert_ids], X_insert, axis=0)
+                NX[X_insert_ids] += 1
+                last_action[X_insert_ids] = 1
+            if len(finished_ids) > 0:
+                finished[finished_ids] = True
+            # print finished
+
+        return X, A, NX, NA, last_action, finished
+
+class Builder(object, metaclass=ABCMeta):
+
+    def __init__(self, model_loc, gpu_id=None):
+        with open(os.path.join(model_loc, 'configs.json')) as f:
+            configs = json.load(f)
+
+        self.mdl = self.__class__._get_model(configs)
+
+        self.ctx = mx.gpu(gpu_id) if gpu_id is not None else mx.cpu()
+        self.mdl.load_parameters(os.path.join(model_loc, 'ckpt.params'), ctx=self.ctx, allow_missing=True)
+
+    @staticmethod
+    def _get_model(configs):
+        raise NotImplementedError
+
+    @abstractmethod
+    def sample(self, num_samples, *args, **kwargs):
+        raise NotImplementedError
+
+
+class CVanilla_RNN_Builder(Builder):
+
+    @staticmethod
+    def _get_model(configs):
+        return CVanillaMolGen_RNN(get_mol_spec().num_atom_types, get_mol_spec().num_bond_types, D=2, **configs)
+
+
+    def sample(self, num_samples, c, output_type='mol', sanitize=True, random=True):
+        if len(c.shape) == 1:
+            c = np.stack([c, ]*num_samples, axis=0)
+
+        with autograd.predict_mode():
+            # step one
+            finished = [False, ] * num_samples
+
+            def get_init():
+                self.mdl.mode = 'decode_0'
+                _c = nd.array(c, dtype='float32', ctx=self.ctx)
+                init = self.mdl(_c).asnumpy()
+                return init
+
+            outputs = _decode_step(X=None, A=None, NX=None, NA=None, last_action=None, finished=finished,
+                                   get_init=get_init, get_action=None,
+                                   n_node_types=self.mdl.N_A, n_edge_types=self.mdl.N_B,
+                                   random=random)
+
+            # If outputs is None
+            if outputs is None:
+                return None
+            X, A, NX, NA, last_action, finished = outputs
+
+            count = 1
+            h = np.zeros([self.mdl.N_rnn, num_samples, self.mdl.F_c[-1]], dtype=np.float32)
+            while not np.all(finished) and count < 100:
+                def get_action(inputs):
+                    self.mdl.mode = 'decode_step'
+                    _h = nd.array(h[:, np.logical_not(finished), :], ctx=self.ctx, dtype='float32')
+                    _c = nd.array(c[np.logical_not(finished), :], ctx=self.ctx, dtype='float32')
+                    _X, _A_sparse, _NX, _NX_rep, _mask, _NX_cum = self.to_nd(inputs)
+                    _append, _connect, _end, _h = self.mdl(_X, _A_sparse, _NX, _NX_rep, _mask, _NX_cum, _h, _c, _NX_rep)
+                    h[:, np.logical_not(finished), :] = _h[0].asnumpy()
+                    return _append.asnumpy(), _connect.asnumpy(), _end.asnumpy()
+
+                outputs = _decode_step(X, A, NX, NA, last_action, finished,
+                                       get_init=None, get_action=get_action,
+                                       n_node_types=self.mdl.N_A, n_edge_types=self.mdl.N_B,
+                                       random=random)
+                X, A, NX, NA, last_action, finished = outputs
+
+                count += 1
+
+            graph_list = []
+
+            cumsum_X_ = np.cumsum(np.pad(NX, [[1, 0]], mode='constant')).tolist()
+            cumsum_A_ = np.cumsum(np.pad(NA, [[1, 0]], mode='constant')).tolist()
+
+            for cumsum_A_pre, cumsum_A_post, \
+                cumsum_X_pre, cumsum_X_post in zip(cumsum_A_[:-1], cumsum_A_[1:],
+                                                   cumsum_X_[:-1], cumsum_X_[1:]):
+                graph_list.append([X[cumsum_X_pre:cumsum_X_post], A[cumsum_A_pre:cumsum_A_post, :]])
+
+            if output_type=='graph':
+                return graph_list
+            elif output_type == 'mol':
+                return get_mol_from_graph_list(graph_list, sanitize)
+            elif output_type == 'smiles':
+                mol_list = get_mol_from_graph_list(graph_list, sanitize=True)
+                smiles_list = [Chem.MolToSmiles(m) if m is not None else None for m in mol_list]
+                return smiles_list
+            else:
+                raise ValueError('Unrecognized output type')
+
+    def to_nd(self, inputs):
+        X, A, NX, NX_rep, mask = inputs[:-2]
+        NX_cum = np.cumsum(NX)
+
+        # convert to ndarray
+        _to_ndarray = lambda _x: nd.array(_x, self.ctx, 'int64')
+        X, NX, NX_rep, mask, NX_cum = \
+            _to_ndarray(X), _to_ndarray(NX), _to_ndarray(NX_rep), _to_ndarray(mask), _to_ndarray(NX_cum)
+        A_sparse = []
+        for _A_i in A:
+            if _A_i.shape[0] == 0:
+                A_sparse.append(None)
+            else:
+                # transpose may not be supported in gpu
+                _A_i = np.concatenate([_A_i, _A_i[:, [1, 0]]], axis=0)
+
+                # construct csr matrix ...
+                _data = np.ones((_A_i.shape[0],), dtype=np.float32)
+                _row, _col = _A_i[:, 0], _A_i[:, 1]
+                _A_sparse_i = nd.sparse.csr_matrix((_data, (_row, _col)),
+                                                   shape=tuple([int(X.shape[0]), ] * 2),
+                                                   ctx=self.ctx, dtype='float32')
+
+                # append to list
+                A_sparse.append(_A_sparse_i)
+        return X, A_sparse, NX, NX_rep, mask, NX_cum

requirements.txt

@@ -0,0 +1,17 @@
+Flask
+gunicorn  
+rdkit
+transformers
+bio-embeddings
+torch
+huggingface_hub
+molvs
+numpy==1.23.5
+mxnet==1.8
+networkx
+scipy
+pandas
+ipython
+accelerate>=0.26.0
+gdown==4.6.0
+requests

runtime.txt

@@ -0,0 +1 @@
+python-3.8.3

templates/index.html

@@ -0,0 +1,93 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Protein to SMILES Generator</title>
+    <style>
+        body {
+            font-family: 'Arial', sans-serif;
+            background: linear-gradient(to right, #4facfe, #00f2fe);
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            margin: 0;
+        }
+        .container {
+            background: white;
+            padding: 40px;
+            border-radius: 15px;
+            box-shadow: 0px 6px 15px rgba(0, 0, 0, 0.3);
+            width: 90%;
+            max-width: 1200px;
+            text-align: center;
+        }
+        h2 {
+            font-size: 32px;
+            color: #333;
+            margin-bottom: 20px;
+        }
+        textarea {
+            width: 100%;
+            height: 300px;
+            border: 2px solid #ddd;
+            border-radius: 10px;
+            padding: 15px;
+            resize: none;
+            font-size: 18px;
+        }
+        button {
+            margin-top: 20px;
+            padding: 14px 24px;
+            font-size: 18px;
+            background-color: #007bff;
+            color: white;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: background 0.3s ease;
+        }
+        button:hover {
+            background-color: #0056b3;
+        }
+        .message {
+            margin-top: 20px;
+            font-size: 18px;
+            color: #28a745;
+        }
+        .download-btn {
+            display: inline-block;
+            margin-top: 20px;
+            padding: 14px 24px;
+            font-size: 18px;
+            background-color: #28a745;
+            color: white;
+            text-decoration: none;
+            border-radius: 8px;
+            transition: background 0.3s ease;
+        }
+        .download-btn:hover {
+            background-color: #218838;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h2>Protein to SMILES Generator</h2>
+        <form method="POST">
+            <textarea name="sequence" placeholder="Enter non-FASTA protein sequence..."></textarea><br>
+            <button type="submit">Generate SMILES</button>
+        </form>
+        
+        {% if message %}
+            <p class="message">{{ message }}</p>
+        {% endif %}
+        
+        {% if file_path %}
+            <p>Time taken: {{ time_taken }} seconds</p>
+            <a href="{{ url_for('download_file') }}" class="download-btn">Download SMILES</a>
+        {% endif %}
+    </div>
+</body>
+</html>