Chapter 3: Selecting Materials Science & Machine Learning Journals

Recommends optimal journals from research content using decision trees.

# Requirements:
# - Python 3.9+
# - pandas>=2.0.0, <2.2.0

"""
Purpose: Demonstrate machine learning model training and evaluation
Target: Beginner to Intermediate
Execution time: 5-10 seconds
Dependencies: None
"""

import pandas as pd
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.preprocessing import LabelEncoder

# Research type and recommended journal data
data = {
    'research_type': ['GNN novel method', 'GNN materials-specific', 'transfer learning',
                      'energy materials', 'metallic materials', 'molecular materials',
                      'database', 'software', 'review'],
    'novelty': ['high', 'medium', 'medium', 'medium', 'medium', 'medium', 'low', 'low', 'low'],
    'experimental': ['no', 'no', 'no', 'yes', 'yes', 'yes', 'no', 'no', 'no'],
    'recommended_journal': [
        'Nature Machine Intelligence',
        'npj Computational Materials',
        'ACS Central Science',
        'Energy Storage Materials',
        'Acta Materialia',
        'J. Chem. Info. & Model.',
        'Scientific Data',
        'J. Cheminformatics',
        'Materials Today'
    ]
}

df = pd.DataFrame(data)

# Label encoding
le_type = LabelEncoder()
le_nov = LabelEncoder()
le_exp = LabelEncoder()

X = pd.DataFrame({
    'type': le_type.fit_transform(df['research_type']),
    'novelty': le_nov.fit_transform(df['novelty']),
    'experimental': le_exp.fit_transform(df['experimental'])
})
y = df['recommended_journal']

# Decision tree model
clf = DecisionTreeClassifier(max_depth=3, random_state=42)
clf.fit(X, y)

# Visualize decision tree (text format)
tree_rules = export_text(clf, feature_names=['research_type', 'novelty', 'experimental'])
print("=== Journal Selection Decision Tree ===")
print(tree_rules)

# Recommendation example for new research
def recommend_journal(research_type, novelty, has_experimental):
    """
    Recommend journal from research type

    Parameters:
    -----------
    research_type : str
        Research type (e.g., 'GNN novel method', 'energy materials')
    novelty : str
        Novelty level ('high', 'medium', 'low')
    has_experimental : str
        Experimental validation ('yes', 'no')
    """
    # Encoding
    type_enc = le_type.transform([research_type])[0]
    nov_enc = le_nov.transform([novelty])[0]
    exp_enc = le_exp.transform([has_experimental])[0]

    # Prediction
    X_new = [[type_enc, nov_enc, exp_enc]]
    prediction = clf.predict(X_new)[0]

    return prediction

# Test cases
test_cases = [
    ('GNN novel method', 'high', 'no'),
    ('energy materials', 'medium', 'yes'),
    ('database', 'low', 'no')
]

print("\n=== Recommendation Examples ===")
for research_type, novelty, experimental in test_cases:
    journal = recommend_journal(research_type, novelty, experimental)
    print(f"{research_type} (novelty: {novelty}, experimental: {experimental}) → {journal}")

Scores multiple candidate journals and determines optimal submission order.

# Requirements:
# - Python 3.9+
# - numpy>=1.24.0, <2.0.0
# - pandas>=2.0.0, <2.2.0

"""
Purpose: Demonstrate data manipulation and preprocessing
Target: Intermediate
Execution time: 10-30 seconds
Dependencies: None
"""

import numpy as np
import pandas as pd

# Candidate journal data
journals = {
    'journal': ['npj Computational Materials', 'Computational Materials Science',
                'Digital Discovery', 'Machine Learning: Sci. & Tech.'],
    'impact_factor': [9.0, 3.5, 5.0, 6.8],
    'review_time_months': [2.5, 3.0, 1.5, 2.5],
    'acceptance_rate': [0.25, 0.45, 0.35, 0.40],
    'relevance_score': [0.95, 0.85, 0.80, 0.90]  # 0-1 range
}

df = pd.DataFrame(journals)

def calculate_priority_score(row, weights):
    """
    Calculate priority score

    Parameters:
    -----------
    row : Series
        Journal data row
    weights : dict
        Weight for each factor
    """
    # Normalization
    if_norm = row['impact_factor'] / df['impact_factor'].max()
    time_norm = 1 - (row['review_time_months'] / df['review_time_months'].max())
    acc_norm = row['acceptance_rate']
    rel_norm = row['relevance_score']

    # Weighted score
    score = (weights['if'] * if_norm +
             weights['time'] * time_norm +
             weights['acceptance'] * acc_norm +
             weights['relevance'] * rel_norm)

    return score

# Three strategy patterns
strategies = {
    'Conservative': {'if': 0.2, 'time': 0.1, 'acceptance': 0.5, 'relevance': 0.2},
    'Balanced': {'if': 0.3, 'time': 0.2, 'acceptance': 0.3, 'relevance': 0.2},
    'High-IF': {'if': 0.6, 'time': 0.1, 'acceptance': 0.1, 'relevance': 0.2}
}

print("=== Submission Priority (by Strategy) ===\n")

for strategy_name, weights in strategies.items():
    print(f"【{strategy_name}】")
    df['priority_score'] = df.apply(lambda row: calculate_priority_score(row, weights), axis=1)
    df_sorted = df.sort_values('priority_score', ascending=False)

    for idx, (i, row) in enumerate(df_sorted.iterrows(), 1):
        print(f"  {idx}. {row['journal']}")
        print(f"       Score: {row['priority_score']:.3f} (IF: {row['impact_factor']}, "
              f"Acceptance: {row['acceptance_rate']:.0%})")
    print()

# Calculate expected time to acceptance
df['expected_time_to_accept'] = df['review_time_months'] / df['acceptance_rate']
print("=== Expected Time to Acceptance (Average) ===")
for _, row in df.iterrows():
    print(f"{row['journal']}: {row['expected_time_to_accept']:.1f} months")