实现逻辑回归算法来预测用户流失是一个重要且丰富的任务。首先，我们需要进行数据预处理，包括数据归一化和非数值数据处理。然后，我们可以将数据集划分为训练集和验证集，并开始训练模型。在训练过程中，我们可以 precision、recall 和 accuracy 为评价指标，评估模型的性能，并判断是否存在欠拟合或过拟合的情况。

在建模过程中，我们可以将问题分别建模成二分类问题和回归问题。在二分类问题中，我们可以使用逻辑回归，以 MSE（均方误差）作为损失函数来进行训练。而在回归问题中，我们同样可以使用 MSE 为损失函数。接下来，我将逐步解释每个步骤，并提供相应的代码示例和可视方法以支持你完成这一任务。

首先，我们需要导入必要的库和准备数据集。然后进行数据预处理，如数据归一化和非数值数据处理。最后，使用逻辑回归模型训练，并使用 precision、recall 和 accuracy 作为评价指进行模型估。同时，需要训练过程的损失函数和标的变化用曲线可视化。接着，我们将尝试将该问题建模成一个回归型，使用 MSE 作为损失函数来进行训练，并同样使用 precision、recall 和 accuracy 作为评价指标，并将训练过程的损失函数和标的变化用曲线可视化。

为了此任务更具体和际，我需要你提供一些关于数据集的细节，例如特征/属性和标签的描述，以及数据集的模和格式。这样我可以为你提供更加准确和相关的代码示例和方法。

这是一个很大的任务，包括了许多步骤，如数据预处理、逻辑回归分类和回归分析，以及评价指标的计算。下面是一些基本的Python代码片段，你可以结合这些代码片段完成你的任务。

. 首，我们需要导入必要的库：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, mean_squared_error
from sklearn.preprocessing import StandardScaler, LabelEncoder
import matplotlib.pyplot as plt
import seaborn as sns

2. 然后我们可以加载数据，进行初步的数据预处理，包括归一化和编码非数值数据：

data = pd.read_csv('your_data.csv')

encoder = LabelEncoder()
categorical_features = ['non_numeric_feature1','non_numeric_feature2'] # replace these with your's non-numeric features
for feature in categorical_features:
    data[feature] = encoder.fit_transform(data[feature])

scaler = StandardScaler()
numeric_features = ['numeric_feature1', 'numeric_feature2'] # replace these with your data's numeric features
data[numeric_features] = scaler.fit_transform(data[numeric_features])

3. 接着我们可以划分训练机和验证集：

features = data.drop('target', axis = 1) # replace 'target' with your data's target column
labels = data['target']
train_features, test_features, train_labels, test_labels = train_test_split(features, labels, test_size=0., random_state=123)

4. 现在我们可以训练逻辑回归模型，首先是二分类模型：

model = LogisticRegression()
model.fit(train_features, train_labels)

predictions = model.predict(test_features)
accuracy = accuracy_score(test_labels, predictions)
precision = precision_score(test_labels, predictions)
recall = recall_score(test_labels, predictions)

5. 接着我们可以训练回归模型，然后比较二者的评价指标：

from sklearn.linear_model import LinearRegression
model_regression = LinearRegression()
model_regression.fit(train_features, train_labels)

predictions_regression model_regression.predict(test_features)
mse = mean_squared_error(test_labels, predictions_regression)

6.比二者的评价指标：

print(" Classification Metrics\n----------------------")
print("Accuracy: ", accuracy)
print("Precision: ", precision)
print("Recall: ", recall)

print("\nRegression Metrics\n----------------------")
print("Mean Squared Error: ", mse```

7. 可视化评分和损失函数的变化：

这部分通常需要在训练过程中记录每个epoch的损失和评分，然后使用matplotlib或seaborn等库进行可视化。这部分在sklearn出于模型的简洁性，并没有直提供。如果你需要详细的损失函数变化，可能需要使用更底层的机器学习库，如TensorFlow或PyTorch。

请注意面所有代码都假定了数据的特定形式和，你需要根据你自己的数据用适当的变量名替换。此外，你可能需要添加的数据预处理步骤，视你的数据的实际情况而定。  

我明白你的要求，你需要手动实现逻辑回归模型，并且希望在每一步迭代更新模型的过程，使用现成的损失函数和梯度下降方法。下面是一个使用PyTorch的例子：

import torch
import torch.nn as nn
from torch.autograd import Variable

# 定义逻辑回归模型
class LogisticRegressionModel(nn.Module):
    def __init__(self, input_size, output_size):
        super(LogisticRegressionModel, self).__init__()
        self.linear = nn.Linear(input_dim, output_dim)

    def forward(self, x):
        y_pred = torch.sigmoid(self.linear(x))
        return y_pred

# 模型参数
input_dim = train_features.shape[1]
output_dim = 1 # Binary classification
learning_rate = 0.01
epochs = 100

# 创建逻辑归模型
model = LogisticRegression(input_dim, output_dim)

# 损失函数和优化器
criterion = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(epochs):
    model.train() # 设定模型为训练模式
    
    optimizer.zero_grad # 清所有优化梯度
    
    # 数据封装成Variable
    inputs = Variable(torch.Tensor(train_features.astype('float32')))
    labels = Variable(torch.Tensor(train_labels.astype('float32')))

    outputs = model(inputs) # 前向传导

    loss = criterion(outputs, labels)  # 计算损失    loss.backward() # 反向传导
    optimizer.step() # 参数更新

    # 评价模型
    model.eval() # 设定模型为评价模式
    inputs_test = Variable(torch.Tensor(test_features.astype('float32')))
    labels_test = Variable(torch.Tensor(test_labels.astype('float32')))
    outputs_test = model(inputs_test)
    
    # 计算损失和精度
    test_loss criterion(outputs_test, labels_test)  # 计损失
    predicted = (outputs_test.data > 0.5) #测结果
    accuracy = (predicted == labels_test.data).sum() / float(labels_test.size(0)) # 计算准确率
    
    print('Epoch {}/{}, Loss: {:.4f}, Test Loss {:.4f Test Accuracy: {:.4f}'.format(epoch+1, epochs, loss.data, test_loss.data, accuracy```

这个代码实现了一个基本的逻辑回归模型，并使用二元交叉熵损失去训练这个模。这个代码有一些基本的步骤，例如模型的前向传播，计算失，反向传播，梯度下降更新参数，并记录每次迭代中模型的失和精度。这段代码仅供参考，希望你的实际项目中对其进行适当的调整以适应你的数据和需求。