上一篇文章在这里Android架构体系–结构和组件选择
通过mvvm模式和room（google提供的持久化库）来进行user类的显示/添加功能
view:MainActivity(显示user)，AddNewUserActivity(添加user)
viewmodel:UserViewModel(负责与model层通信，持有repository实例，并提供获取/插入user的操作）
model:user(实例类),userdao,appdatabase（初始化数据库实例类）,userrep[……]
随着业务的发展，Android以前那种瀑布流式的开发模式的弊端越来越明显，例如
1.无法拆分逻辑和页面
都写在Activity中，无法拆分，非常混乱
2.无法测试等
由于界面和逻辑连在一起，无法写出良好的单元测试
3.过长的Activity代码
由于各种逻辑都在一起，经常会有三四百行的超长文件
这时候我们就需要对项目进行良好的架构来解决这些问题，Android官方提出MVVM架构模式并推出了诸多工具来实现，与最初不同的是，android官方推出了多个新的工具库来解决实现过程中的问题。
将整个项目分为三个层次
V[……]
分为多层的机器学习算法，将上一层的输出作为下一层的输入，直到最后一层输出
用于基本的分类或者预测学习，是一种基础的神经网络机器学习算法
同样为多层的神经网络，每次使用relu激励函数加上卷积层和池化层进行处理，最后通过全连接层输出
主要用在图像识别，每次卷积/池化都能过滤信息，最终得到判断结果
把神经网络上次的输出作为输入之一再次进行运算的神经网络结构
主要用于有顺序的场景，比如语义和语法等具有连续性的场景学习，但是每次只接收上一次的[……]
1.基于内容的推荐算法
2.协同过滤推荐算法
1.需要知道每个项目的特征，以及详细的特征值，比如一个电影的爱情元素占比，动作成分占比等
2.需要用户事先评价几部电影，得到用户的评分特征向量，比如，对动作电影的偏好程度等
3.把特征和用户偏好相乘，得到预估得分，得到推荐结果集
需要详细知道每个元素的具体特征和值，这是基本不可能实现的
1.随机初始化用户偏好θ和项目特征x
2.直接使用代价函数同时求上述两个随机变量的最优解，梯度下降或者高级算法均可
3.预测过程与内容推荐相同
1.不需要知道x的具体内[……]
1.收集更多样本
2.使用更小规模的方法
3.增加方法的规模
4.使用多项式
5.增加正则化参数λ
对于线性回归：
对于分类算法：
按照比例6：2：2划分为三个样本，训练集，验证集，测试集
训练集：找到方法参数theta
验证集：确定方法多项式的度数d
测试集：确定正则化参数λ
同上
1.error的计算代码
[crayon-5ae19e51[……]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
function [J grad] = nnCostFunction(nn_params, ... input_layer_size, ... hidden_layer_size, ... num_labels, ... X, y, lambda) Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), ... hidden_layer_size, (input_layer_size + 1)); Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end), ... num_labels, (hidden_layer_size + 1));%从参数中分离出每一层的参数 m = size(X, 1); J = 0; Theta1_grad = zeros(size(Theta1)); Theta2_grad = zeros(size(Theta2));%初始化为0矩阵 h1 = sigmoid([ones(m,1) X]*Theta1'); h2 = sigmoid([ones(m,1) h1]*Theta2');%向前传播 for i = 1:size(y) tempy = 0; for k = 1:num_labels if(k == y(i)) tempy = 1; else tempy = 0; endif%转化y为向量 J += -tempy*log(h2(i,k)) - (1-tempy)*log(1-h2(i,k)); end end J /= rows(y);%代价函数计算 %正则化代价函数 re = 0; for j =1:rows(Theta1) for k =2:columns(Theta1) re += Theta1(j,k)^2; end end for j =1:rows(Theta2) for k =2:columns(Theta2) re += Theta2(j,k)^2; end end re *= lambda/(2*rows(y)); J += re;%正则化代价函数 |
|
1 2 3 4 |
function g = sigmoidGradient(z) g = zeros(size(z)); g = sigmoid(z).*(1-sigmoid(z)); end |
|
1 2 3 4 5 6 |
function W = randInitializeWeights(L_in, L_out) W = zeros(L_out, 1 + L_in); end %调用上面的函数初始化 initial_Theta1 = randInitializeWeights(input_layer_size, hidden_layer_size); initial_Theta2 = randInitializeWeights(hidden_layer_size, num_labels); |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
vy = zeros(rows(y),num_labels); for i = 1:size(y) vy(i,y(i,:)) = 1; end%向量化y X = [ones(m, 1) X];%添加列，1 z2 = X * Theta1'; d3 = h2 - vy; d2 = d3*Theta2(:,2:end).*sigmoidGradient(z2); delta1 = d2'*X; delta2 = d3'* [ones(m,1) sigmoid(z2)];%求d3,d2,del1,del2 Theta1_grad = delta1/m; Theta2_grad = delta2/m;%求grad1,grad2 Theta1(:,1) = 0; Theta2(:,1) = 0; Theta1 = (lambda/m)*Theta1; Theta2 = (lambda/m)*Theta2; Theta1_grad = Theta1_grad +Theta1; Theta2_grad = Theta2_grad+Theta2;%正则化grad grad = [Theta1_grad(:) ; Theta2_grad(:)]; |
|
1 2 3 4 |
lambda = 3; checkNNGradients(lambda);%期望值 debug_J = nnCostFunction(nn_params, input_layer_size, ... hidden_layer_size, num_labels, X, y, lambda);%实际值 |
[crayon-5ae19e51c1e5529[……]
最近接触到springboot，用来初始化项目非常方便，于是拿来初始化了一下mybatis，结果发现，网上大部分的文章都是用注解方法进行mapper配置。
大家都知道，mybatis的一个特点就是所有的sql都在xml里，方便管理，还可以使用动态sql。
于是我开始尝试使用xml配置mapper，过程中遇到了一点点问题，现记录。
1.选择spring init
2.输入信息，第二个是项目名
3.搜索添加要用的依赖，这里注意右边，我选择了三个，web,mybatis,postgresql（也可以选[……]
给出字符串”abc”计算其全排列
如abc,acb,bac,bca,cab,cba
使用递归方法，每次确定一个未使用的字符，再递归寻找下一个未使用的字符，直到生成字符串长度与原来的长度相同，就返回，每次返回之后，要把这次的字符取消标记
|
1 2 3 4 5 6 7 8 9 10 |
def find(int len,int position,string s): if(s.len == len) result.add(s);//添加到结果集 return;//返回 for（int j = position;j < len;j++): if(use[j] == 0)://是否已经使用 use[j] = 1;//标记 s += origin[j];//给生成串加字符 find(len,j+1,s);//进一步递归 use[j] = 0;//取消标记 |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public void result(int k, int i, String s){ if (s.length() == k) { reset[num++] = s; return; } for (int j = i;j < all.size();j++){ if (use[j] != 0)continue; if (use[j] == 0){ use[j] = 1; s += all.get(j); result(k,j+1,s); s = s.substring(0,s.length()-1); use[j] = 0; } } } |
http://codeforces.com/contest/864/problem/C
总路程a，油箱容量b，加油站离出发点f,总共要跑k趟，问，至少需要加油多少次
以每次到达加油站为基准点，判断是否可以跑完下一个端点–加油站的行程，如果可以，不加油，不可以，加油
有几种特殊情况
1.沿着当前方向，跑到端点结束，没有再从端点回加油站的过程
2.根本跑不到加油站
3.沿着当前方向，加一次油跑到下一个端点，结束
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
import java.util.*; /** * Created by u3 on 16-10-16. */ public class Bus{ public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int a = scanner.nextInt(); int b = scanner.nextInt(); int f = scanner.nextInt(); int k = scanner.nextInt(); int current;//现在的油量 int j = 0;//行程数量 int num = 0; current = b - f;//减去第一次跑到加油站的油 while (j < k) { if (current < 0){ j = -1; break; } if (current - 2 * (a - f) >= 0) {//判断到加油站时，能不能到左边再返回不用加油 current -= 2 * (a - f); } else if (current - (a - f) >= 0 && j + 1 == k) {//判断是不是最后一趟，可以直接跑到 j++; continue; }else if (b - (a - f) >= 0 && j + 1 == k) {//判断是不是最后一趟，可以加油跑到 j++; num++; continue; }else {//要加油 current = b - 2 * (a - f); if (current < 0) { j = -1; break; } num++; } j++; if (j == k) break; if (current >= 2 * f) {//判断到加油站时，能不能到右边再返回不用加油 current -= 2 * f; } else if (current - f >= 0 && j + 1 == k) {//判断是不是最后一趟，可以直接跑到 j++; break; } else if(b-f>=0&&j+1==k){//判断是不是最后一趟，可以加油跑到 num++; j++; break; }else{//要加油 current = b - 2 * f; if (current < 0) { j = -1; break; } num++; } j++; if (j == k) break; } if (j == -1) { System.out.println(j); } else { System.out.println(num); } } } |
