<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
from tensorflow import keras

#  Import and read the charity_data.csv.
import pandas as pd 
application_df = pd.read_csv("Resources/charity_data.csv")
application_df.head()
application_df.columns
application_df.index

# Drop the non-beneficial ID columns, 'EIN' and 'NAME'.
#  YOUR CODE GOES HERE
application_df = application_df.drop(columns=['EIN','NAME'])
application_df.head()
# Determine the number of unique values in each column.
#  YOUR CODE GOES HERE
application_df.nunique()

# Look at APPLICATION_TYPE value counts for binning
#  YOUR CODE GOES HERE
application_df['APPLICATION_TYPE'].value_counts()

# Choose a cutoff value and create a list of application types to be replaced
# use the variable name `application_types_to_replace`
#  YOUR CODE GOES HERE
application_types_to_replace = ['T17','T29','T15','T14','T25','T2','T13','T9','T10','T7','T8']
# 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
#  YOUR CODE GOES HERE

counts = application_df['CLASSIFICATION'].value_counts()
# give series and list all diff value counts
counts
# You may find it helpful to look at CLASSIFICATION value counts >1
#  YOUR CODE GOES HERE
counts = counts[counts > 1]
print(counts)
# Choose a cutoff value and create a list of classifications to be replaced
# use the variable name `classifications_to_replace`
#  YOUR CODE GOES HERE
counts = application_df['CLASSIFICATION'].value_counts()
classifications_to_replace =  (counts[counts.cumsum() > .99*len(application_df)].keys().values)

print (classifications_to_replace)
        
# 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`
#  YOUR CODE GOES HERE
application_df = pd.get_dummies(application_df,columns=['APPLICATION_TYPE', 'AFFILIATION', 
                        'CLASSIFICATION','USE_CASE', 'ORGANIZATION', 'STATUS', 'INCOME_AMT',
       'SPECIAL_CONSIDERATIONS'])
application_df
# Split our preprocessed data into our features and target arrays
#  YOUR CODE GOES HERE
X = application_df.drop(columns=['IS_SUCCESSFUL'])

# Prepare targets / labels
Y = application_df['IS_SUCCESSFUL']
# Split the preprocessed data into a training and testing dataset
#  YOUR CODE GOES HERE

X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=.2)

print("Training features")
print(X_train)
print("Training labels")
print(y_train)
print("Test features")
print(X_test)
print("Test labels")
print(y_test)
# 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.
#  YOUR CODE GOES HERE

nn_model = tf.keras.models.Sequential()

# First hidden layer
#  YOUR CODE GOES HERE
nn_model.add(tf.keras.layers.Dense(units=100, activation="relu", input_dim=53))

# Second hidden layer
#  YOUR CODE GOES HERE
nn_model.add(tf.keras.layers.Dense(units=100, activation="relu"))
nn_model.add(tf.keras.layers.Dense(units=100, activation="relu"))

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

# Check the structure of the model
nn_model.summary()
# Compile the model
#  YOUR CODE GOES HERE
nn_model.compile(loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"])
# Train the model
#  YOUR CODE GOES HERE
#
epoch_counter = 0 
class EpochCallback(keras.callbacks.Callback):
    
    def on_epoch_end(self, epoch, logs=None):
        global epoch_counter
        epoch_counter += 1
        keys = list(logs.keys())
        print("End epoch {} of training; got log keys: {}".format(epoch, keys))
        
        if epoch_counter == 5:
             epoch_counter = 0
             nn_model.save_weights("pretrained_weights{}.h5".format(epoch))
      

fit_model = nn_model.fit(X_train_scaled, y_train, epochs=50)

# 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
#  YOUR CODE GOES HERE
nn_model.save("AlphabetSoupCharity_Pptimization.h5")<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10113027959547888, 'fraction_numerical': 0.00892325996430696, 'mean_word_length': 5.508387096774194, 'pattern_counts': {'":': 0, '<': 9, '<?xml version=': 0, '>': 12, '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': '158617', 'license': 'ADSL', 'n_tokens_mistral': 1691, 'n_tokens_neox': 1615, 'n_words': 441, 'path': '.ipynb_checkpoints/Opt_4-checkpoint.ipynb', 'repo_name': 'ghhyc/Deep-Learning-Charity-Funding-Predictor-', 'size': '5043'}