<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[javaisnotgood的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/javaisnotgood</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; javaisnotgood]]></copyright><item><title><![CDATA[lightgbm模型fine-tune微调]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/124678918</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/124678918</guid><author>javaisnotgood</author><pubDate>Tue, 10 May 2022 00:38:46 +0800</pubDate><description><![CDATA[1.参数input_model置为需要微调的模型，这种方式会额外增加n棵树继续学习；

2.lgb.train(init_model=微调所需模型,keep_training_booster=True)


model = lgb.train(params,
                  lgb_train,
                  num_boost_round=1000,
                  valid_sets=lgb_eval,
                  ]]></description><category></category></item><item><title><![CDATA[CVR预估建模中样本的问题]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/120960350</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/120960350</guid><author>javaisnotgood</author><pubDate>Mon, 25 Oct 2021 21:06:56 +0800</pubDate><description><![CDATA[1.样本选择

    传统的cvr建模往往选择点击后的转化和未转化样本，这样训练出来的模型用在全量样本上进行预估，而非只对点击样本进行预估。即是说，训练数据与实际要预测的数据来自不同分布，这个偏差对模型的泛化能力构成了很大挑战，会导致样本选择偏差；

    通过加入一些未点击样本作为label为0的负样本，可以缓解样本选择偏差；

    选择全量样本作为训练样本，在这种策略下我们假设未点击的样本肯定不会转化，但是我们不知道当未点击用户点击了之后是否会转化，如果直接使用0作为它们...]]></description><category></category></item><item><title><![CDATA[剑指 Offer 16. 数值的整数次方 - python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/110653883</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/110653883</guid><author>javaisnotgood</author><pubDate>Fri, 04 Dec 2020 16:20:51 +0800</pubDate><description><![CDATA[剑指 Offer 16. 数值的整数次方 python实现
描述
实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。
示例 1:
输入: 2.00000, 10
输出: 1024.00000
示例 2:
输入: 2.10000, 3
输出: 9.26100
示例 3:
输入: 2.00000, -2
输出: 0.25000
解释: 2-2 = 1/22 = 1/4 = 0.25
来源：力扣（Lee]]></description><category></category></item><item><title><![CDATA[剑指 Offer 13. 机器人的运动范围 - python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/110476104</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/110476104</guid><author>javaisnotgood</author><pubDate>Wed, 02 Dec 2020 11:57:49 +0800</pubDate><description><![CDATA[剑指 Offer 13. 机器人的运动范围
介绍
地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？
来源：力扣（LeetCode）
链接：https:/]]></description><category></category></item><item><title><![CDATA[房产行业聊天问答匹配 -pytorch方案]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/109736643</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/109736643</guid><author>javaisnotgood</author><pubDate>Tue, 17 Nov 2020 10:08:45 +0800</pubDate><description><![CDATA[房产行业聊天问答匹配
竞赛地址：https://www.datafountain.cn/competitions/474
问题描述

方案
首先将该问题归结为NLP中的NSP任务（预测下一个句子），然后采用目前较为先进的基于chinese预训练的bert系的相关算法。在transformer库中这些算法的使用方式变得更为简单便捷，所以我们使用pytorch + transformer进行建模
代码
详细代码可见
https://github.com/1JasonZhang/Q-A-matching-of-r]]></description><category></category></item><item><title><![CDATA[基于百度UNIT的微信智能问答聊天机器人小程序]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/109506758</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/109506758</guid><author>javaisnotgood</author><pubDate>Thu, 05 Nov 2020 10:43:25 +0800</pubDate><description><![CDATA[微信聊天机器人小程序
方法

登录百度ai开放平台，申请百度unit智能聊天机器人，获取ak和sk密钥。
将密钥复制到chat.js对应处即可。

代码
https://github.com/1JasonZhang/WeChat-QA-Mini-Program-based-on-baidu-UNIT
测试小程序


...]]></description><category></category></item><item><title><![CDATA[顺时针打印矩阵 python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/109477013</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/109477013</guid><author>javaisnotgood</author><pubDate>Tue, 03 Nov 2020 19:38:20 +0800</pubDate><description><![CDATA[剑指 Offer 29. 顺时针打印矩阵
题目描述
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
思路
根据题目实例描述，题意为将矩阵中的元素按顺时针打印出来，方向为
左-&gt;右, 上-]]></description><category></category></item><item><title><![CDATA[leetcode 56. 合并区间 python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/109243726</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/109243726</guid><author>javaisnotgood</author><pubDate>Fri, 23 Oct 2020 15:50:03 +0800</pubDate><description><![CDATA[问题

给出一个区间的集合，请合并所有重叠的区间。

示例 1:

输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例2:

输入: intervals = [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

来源：力扣（LeetCode）
链接：https://...]]></description><category></category></item><item><title><![CDATA[剑指 Offer 07. 重建二叉树 - python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/109024808</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/109024808</guid><author>javaisnotgood</author><pubDate>Mon, 12 Oct 2020 13:50:10 +0800</pubDate><description><![CDATA[输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。



例如，给出

前序遍历 preorder =[3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

  3
 / \
 9 20
  / \
 15  7

思路：首先通过先序遍历序列可以得到树的根节点，然后在中序序列中找到根节点的位置，则以根节点为界限，向左到0,为左子树，向右到len() - 1 位右子树，然...]]></description><category></category></item><item><title><![CDATA[剑指 Offer 25. 合并两个排序的链表 - python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/108978486</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/108978486</guid><author>javaisnotgood</author><pubDate>Fri, 09 Oct 2020 14:59:20 +0800</pubDate><description><![CDATA[输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1-&gt;2-&gt;4, 1-&gt;3-&gt;4
输出：1-&gt;1-&gt;2-&gt;3-&gt;4-&gt;4
限制：

0 &lt;= 链表长度 &lt;= 1000

l1为链表1，l2为链表2

思路：首先定义一个辅助链表来组成结果链表，然后从头开始遍历两个链表，比较两个链表的每个节点，将有序节点插入辅助链表中，当两个链表中某一个遍历完之后跳出迭代，另一链表剩余的节点都大于辅助链表中的节点，]]></description><category></category></item><item><title><![CDATA[257. 二叉树的所有路径 - python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/108402697</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/108402697</guid><author>javaisnotgood</author><pubDate>Fri, 04 Sep 2020 14:04:34 +0800</pubDate><description><![CDATA[提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档




文章目录

前言
	一、pandas是什么？
	二、使用步骤
	1.引入库
		2.读入数据
	
	总结




前言

二叉树为程序员面试的常见问题，本文将对leetcode中257二叉树的所有路径进行讲解。

提示：以下是本篇文章正文内容，下面案例可供参考

一、问题

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明:叶子节点是指没有子节点的节点。

示例:

输入:

 1
/  \
2   3
...]]></description><category></category></item><item><title><![CDATA[对称的二叉树- 基于python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/108358791</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/108358791</guid><author>javaisnotgood</author><pubDate>Wed, 02 Sep 2020 11:38:08 +0800</pubDate><description><![CDATA[剑指 Offer 28. 对称的二叉树
问题描述
请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

示例 1：
输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：
输入：root = [1,2,2,null,3,null,3]
输出：false
思路
看到这个题目首先想到了使用中序遍历，遍历整个二]]></description><category></category></item><item><title><![CDATA[从上到下打印二叉树-基于python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/108339907</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/108339907</guid><author>javaisnotgood</author><pubDate>Tue, 01 Sep 2020 14:04:52 +0800</pubDate><description><![CDATA[从上到下打印二叉树

通过，剑指 Offer 32 - I. 从上到下打印二叉树, 剑指 Offer 32 - II. 从上到下打印二叉树 II，整理广度优先BFS方法。

剑指 Offer 32 - I从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

例如:
给定二叉树: [3,9,20,null,null,15,7],

返回：
[3,9,20,15,7]

思路：可以使用层次遍历方法，利用bfs广度优先遍历的方法进行遍历，然后保存到list中，广度优先遍历借]]></description><category></category></item><item><title><![CDATA[jupyter notebook下配置多kernel]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/107671567</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/107671567</guid><author>javaisnotgood</author><pubDate>Wed, 29 Jul 2020 17:59:45 +0800</pubDate><description><![CDATA[首先创建新虚拟环境


conda create -n new_env python=3.7.3



然后激活虚拟环境,linux下加source,windows下直接activate new_env


source activate new_env

在虚拟环境中安装nb_conda,和ipykernel，ipykernel会自动配置kernel


conda install nb_conda
pip install ipykernel

最后将kernel信息写入jupyter启动项中，--nam]]></description><category></category></item><item><title><![CDATA[剑指 Offer 58 - I. 翻转单词顺序 - python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/107404564</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/107404564</guid><author>javaisnotgood</author><pubDate>Fri, 17 Jul 2020 11:41:03 +0800</pubDate><description><![CDATA[输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. "，则输出"student. a am I"。



示例 1：

输入: "the sky is blue"
输出:"blue is sky the"
示例 2：

输入: " hello world! "
输出:"world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：

输入: "...]]></description><category></category></item><item><title><![CDATA[剑指 Offer 57 - II. 和为s的连续正数序列 - python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/107360026</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/107360026</guid><author>javaisnotgood</author><pubDate>Wed, 15 Jul 2020 14:38:37 +0800</pubDate><description><![CDATA[输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。



示例 1：

输入：target = 9
输出：[[2,3,4],[4,5]]
示例 2：

输入：target = 15
输出：[[1,2,3,4,5],[4,5,6],[7,8]]

来源：力扣（LeetCode）


思路：采用滑动窗口方法，设置左右边界来限制窗口大小，left，right双边界也就是双指针，1.边界如何移动，初始化..]]></description><category></category></item><item><title><![CDATA[两数之和 - 基于python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/106365242</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/106365242</guid><author>javaisnotgood</author><pubDate>Tue, 26 May 2020 21:49:43 +0800</pubDate><description><![CDATA[1. 两数之和

给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。



示例:


给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解法思路：首先想到的是利用双循环暴力搜索的解法，其时间复杂度为O(n^2),复杂度偏高。数组类问题降低时...]]></description><category></category></item><item><title><![CDATA[剑指offer面试题52. 两个链表的第一个公共节点 - 基于python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/106052429</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/106052429</guid><author>javaisnotgood</author><pubDate>Mon, 11 May 2020 13:43:28 +0800</pubDate><description><![CDATA[输入两个链表，找出它们的第一个公共节点。

如下面的两个链表：



在节点 c1 开始相交。



示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为.]]></description><category></category></item><item><title><![CDATA[14.不修改数组找出重复的数字 - 基于python]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/103849338</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/103849338</guid><author>javaisnotgood</author><pubDate>Mon, 06 Jan 2020 00:05:10 +0800</pubDate><description><![CDATA[给定一个长度为n+1n+1的数组nums，数组中所有的数均在1∼n1∼n的范围内，其中n≥1n≥1。

请找出数组中任意一个重复的数，但不能修改输入的数组。

样例


给定 nums = [2, 3, 5, 4, 3, 2, 6, 7]。

返回 2 或 3。


思考题：如果只能使用O(1)O(1)的额外空间，该怎么做呢？

算法
(分治，抽屉原理) O(nlogn)O(nlog...]]></description><category></category></item><item><title><![CDATA[python中*args和**kwargs详解]]></title><link>https://blog.youkuaiyun.com/javaisnotgood/article/details/102524652</link><guid>https://blog.youkuaiyun.com/javaisnotgood/article/details/102524652</guid><author>javaisnotgood</author><pubDate>Sat, 12 Oct 2019 17:58:53 +0800</pubDate><description><![CDATA[*args和**kwargs主要用于函数定义，其可以将不定数量的参数传递给一个函数。

不定数量指的是预先不知道函数使用者会传递多少个参数给你，所有在这个场景下使用这两个关键字。

*args是用来传递一个非键值对的可变数量的参数列表给函数。

例子：


def test_var_args(f_arg, *argv):
    print("first normal arg:", f_arg...]]></description><category></category></item></channel></rss>