<jupyter_start><jupyter_text>Preprocessing<jupyter_code># Import our dependencies
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import pandas as pd
import tensorflow as tf

#  Import and read the charity_data.csv.
import pandas as pd 
application_df = pd.read_csv("../Resources/charity_data.csv")
application_df.head()
# Drop the non-beneficial ID columns, 'EIN' and 'NAME'.
application_df = application_df.drop(columns=['EIN', 'NAME'])
application_df.head(3)
# Determine the number of unique values in each column.
application_df.nunique() 
# Look at APPLICATION_TYPE value counts for binning
application_count = application_df['APPLICATION_TYPE'].value_counts()

# Pulling the application names as well to help label the grouped data.
application_names = application_df['APPLICATION_TYPE'].value_counts().index.tolist()
# Choose a cutoff value and create a list of application types to be replaced
# use the variable name `application_types_to_replace`
application_types_to_replace = []

# Using 200 as the cut off, this will read the data and pull the names of any applications with less than 200 filed.
for i in range(len(application_count)):
    if application_count[i] < 200:
        application_types_to_replace.append(application_names[i])

    
# Replace in dataframe
for app in application_types_to_replace:
    application_df['APPLICATION_TYPE'] = application_df['APPLICATION_TYPE'].replace(app,"Other")

# Check to make sure binning was successful
application_df['APPLICATION_TYPE'].value_counts()
# Look at CLASSIFICATION value counts for binning

classification_count = application_df['CLASSIFICATION'].value_counts()

# Pulling the CLASSIFICATION labels as well.
classification_labels = application_df['CLASSIFICATION'].value_counts().index.tolist()
# You may find it helpful to look at CLASSIFICATION value counts >1
for i in range(len(classification_count)):
    if classification_count[i] > 1:
        print(classification_count[i])
# Choose a cutoff value and create a list of classifications to be replaced
# use the variable name `classifications_to_replace`
classifications_to_replace = []

# Using 200 as the cut off, this will read the data and pull the names of any applications with less than 200 filed.
for i in range(len(classification_count)):
    if classification_count[i] < 200:
        classifications_to_replace.append(classification_labels[i])
# Replace in dataframe
for cls in classifications_to_replace:
    application_df['CLASSIFICATION'] = application_df['CLASSIFICATION'].replace(cls,"Other")
    
# Check to make sure binning was successful
application_df['CLASSIFICATION'].value_counts()
# Convert categorical data to numeric with `pd.get_dummies`
categorical_columns = ["APPLICATION_TYPE","AFFILIATION","CLASSIFICATION","USE_CASE","ORGANIZATION","INCOME_AMT","SPECIAL_CONSIDERATIONS"]
onehot_application_df = pd.get_dummies(application_df, columns=categorical_columns,drop_first=True)

onehot_application_df.head()
# Split our preprocessed data into our features and target arrays
y = onehot_application_df["IS_SUCCESSFUL"]
X = onehot_application_df.drop("IS_SUCCESSFUL", axis=1)

# Split the preprocessed data into a training and testing dataset
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
# Create a StandardScaler instances
scaler = StandardScaler()

# Fit the StandardScaler
X_scaler = scaler.fit(X_train)

# Scale the data
X_train_scaled = X_scaler.transform(X_train)
X_test_scaled = X_scaler.transform(X_test)<jupyter_output><empty_output><jupyter_text>Compile, Train and Evaluate the Model<jupyter_code>#  Define the model - deep neural net, i.e., the number of input features and hidden nodes for each layer.
nn_model = tf.keras.models.Sequential()

# First hidden layer
nn_model.add(tf.keras.layers.Dense(units=95, activation="relu", input_dim=38)) 

# Second hidden layer
nn_model.add(tf.keras.layers.Dense(units=26, activation="relu")) 

# Output layer
nn_model.add(tf.keras.layers.Dense(units=1, activation="sigmoid")) 

# Check the structure of the model
nn_model.summary() 
# Compile the model
nn_model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"]) 
# Create a callback that saves the model's weights every 5 epochs.
from keras.callbacks import ModelCheckpoint
callback = ModelCheckpoint("best_model.hdf5", monitor='loss', verbose=1, save_best_only=True, mode='auto', period=5)

# Train the model
fit_model = nn_model.fit(X_train_scaled, y_train, epochs=100) 
# Evaluate the model using the test data
model_loss, model_accuracy = nn_model.evaluate(X_test_scaled,y_test,verbose=2)
print(f"Loss: {model_loss}, Accuracy: {model_accuracy}")
# Export our model to HDF5 file
nn_model.save("AlphabetSoupCharity.h5")<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.09204238520673177, 'fraction_numerical': 0.008518595470600457, 'mean_word_length': 6.665605095541402, 'pattern_counts': {'":': 0, '<': 11, '<?xml version=': 0, '>': 11, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '2', 'dir': 'jupyter-structured-clean-dedup', 'id': '455170', 'license': 'ADSL', 'n_tokens_mistral': 1527, 'n_tokens_neox': 1449, 'n_words': 415, 'path': 'AlphabetSoupCharity_Optimzation.ipynb', 'repo_name': 'Emilydada/Charity_Funder_Challenge', 'size': '4813'}